javaEE項目中異常處理

時間  2019-11-07
標籤 javaee 項目 異常 處理 欄目 Java 简体版
原文   原文鏈接
爲何要在J2EE項目中談異常處理呢？可能許多java初學者都想說：「異常處理不就是try….catch…finally嗎？這誰都會啊！」。筆者在初學java時也是這樣認爲的。如何在一個多層的j2ee項目中定義相應的異常類？在項目中的每一層如何進行異常處理？異常什麼時候被拋出？異常什麼時候被記錄？異常該怎麼記錄？什麼時候須要把checked Exception轉化成unchecked Exception ，什麼時候須要把unChecked Exception轉化成checked Exception?異常是否應該呈現到前端頁面？如何設計一個異常框架？本文將就這些問題進行探討。
1． JAVA異常處理
在面向過程式的編程語言中，咱們能夠經過返回值來肯定方法是否正常執行。好比在一個c語言編寫的程序中，若是方法正確的執行則返回1.錯誤則返回0。在vb或delphi開發的應用程序中，出現錯誤時，咱們就彈出一個消息框給用戶。
經過方法的返回值咱們並不能得到錯誤的詳細信息。可能由於方法由不一樣的程序員編寫，當同一類錯誤在不一樣的方法出現時，返回的結果和錯誤信息並不一致。
因此java語言採起了一個統一的異常處理機制。
什麼是異常？運行時發生的可被捕獲和處理的錯誤。
在java語言中，Exception是全部異常的父類。任何異常都擴展於Exception類。Exception就至關於一個錯誤類型。若是要定義一個新的錯誤類型就擴展一個新的Exception子類。採用異常的好處還在於能夠精確的定位到致使程序出錯的源代碼位置,並得到詳細的錯誤信息。
Java異常處理經過五個關鍵字來實現，try,catch,throw ,throws, finally。具體的異常處理結構由try….catch….finally塊來實現。try塊存放可能出現異常的java語句，catch用來捕獲發生的異常，並對異常進行處理。Finally塊用來清除程序中未釋放的資源。無論理try塊的代碼如何返回，finally塊都老是被執行。
一個典型的異常處理代碼
java 代碼
  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();//得到數據鏈接
  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();
  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. }
能夠看出Java的異常處理機制具備的優點：
給錯誤進行了統一的分類，經過擴展Exception類或其子類來實現。從而避免了相同的錯誤可能在不一樣的方法中具備不一樣的錯誤信息。在不一樣的方法中出現相同的錯誤時，只須要throw 相同的異常對象便可。
得到更爲詳細的錯誤信息。經過異常類，能夠給異常更爲詳細，對用戶更爲有用的錯誤信息。以便於用戶進行跟蹤和調試程序。
把正確的返回結果與錯誤信息分離。下降了程序的複雜度。調用者無須要對返回結果進行更多的瞭解。
強制調用者進行異常處理，提升程序的質量。當一個方法聲明須要拋出一個異常時，那麼調用者必須使用try….catch塊對異常進行處理。固然調用者也可讓異常繼續往上一層拋出。
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 異常必須強制調用者進行捕獲或繼續拋出)
unChecked異常也稱爲運行時異常，一般RuntimeException都表示用戶沒法恢復的異常，如沒法得到數據庫鏈接，不能打開文件等。雖然用戶也能夠像處理checked異常同樣捕獲unChecked異常。可是若是調用者並無去捕獲unChecked異常時，編譯器並不會強制你那麼作。
好比一個把字符轉換爲整型數值的代碼以下：
java 代碼
  1. String str = 「123」;
  2. int value = Integer.parseInt(str);
parseInt的方法簽名爲：
java 代碼
  1. public staticint parseInt(String s)throws NumberFormatException
當傳入的參數不能轉換成相應的整數時，將會拋出NumberFormatException。由於NumberFormatException擴展於RuntimeException，是unChecked異常。因此調用parseInt方法時無須要try…catch
由於java不強制調用者對unChecked異常進行捕獲或往上拋出。因此程序員老是喜歡拋出unChecked異常。或者當須要一個新的異常類時，老是習慣的從RuntimeException擴展。當你去調用它些方法時，若是沒有相應的catch塊，編譯器也老是讓你經過,同時你也根本無須要去了解這個方法倒底會拋出什麼異常。看起來這彷佛卻是一個很好的辦法，可是這樣作倒是遠離了java異常處理的真實意圖。而且對調用你這個類的程序員帶來誤導，由於調用者根本不知道須要在什麼狀況下處理異常。而checked異常能夠明確的告訴調用者，調用這個類須要處理什麼異常。若是調用者不去處理，編譯器都會提示而且是沒法編譯經過的。固然怎麼處理是由調用者本身去決定的。
因此Java推薦人們在應用代碼中應該使用checked異常。就像咱們在上節提到運用異常的好外在於能夠強制調用者必須對將會產生的異常進行處理。包括在《java Tutorial》等java官方文檔中都把checked異常做爲標準用法。
使用checked異常，應意味着有許多的try…catch在你的代碼中。當在編寫和處理愈來愈多的try…catch塊以後，許多人終於開始懷疑checked異常倒底是否應該做爲標準用法了。
甚至連大名鼎鼎的《thinking in java》的做者Bruce Eckel也改變了他曾經的想法。Bruce Eckel甚至主張把unChecked異常做爲標準用法。並發表文章，以試驗checked異常是否應該從java中去掉。Bruce Eckel語：「當少許代碼時，checked異常無疑是十分優雅的構思，並有助於避免了許多潛在的錯誤。可是經驗代表，對大量代碼來講結果正好相反」
關於checked異常和unChecked異常的詳細討論能夠參考
使用checked異常會帶來許多的問題。
checked異常致使了太多的try…catch 代碼
可能有不少checked異常對開發人員來講是沒法合理地進行處理的，好比SQLException。而開發人員卻不得不去進行try…catch。當開發人員對一個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異常致使了許多難以理解的代碼產生
當開發人員必須去捕獲一個本身沒法正確處理的checked異常，一般的是從新封裝成一個新的異常後再拋出。這樣作並無爲程序帶來任何好處。反而使代碼晚難以理解。
就像咱們使用JDBC代碼那樣，須要處理很是多的try…catch.，真正有用的代碼被包含在try…catch以內。使得理解這個方法變理困難起來
checked異常致使異常被不斷的封裝成另外一個類異常後再拋出
java 代碼
  1. public void methodA()throws ExceptionA{
  2. …..
  3. throw new ExceptionA();
  4. }
  6. public void methodB()throws ExceptionB{
  7. try{
  8. methodA();
  9. ……
  10. }catch(ExceptionA ex){
  11. throw new ExceptionB(ex);
  12. }
  13. }
  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異常比傳統編程的錯誤返回值要好用得多。經過編譯器來確保正確的處理異常比經過返回值判斷要好得多。
若是一個異常是致命的，不可恢復的。或者調用者去捕獲它沒有任何益處，使用unChecked異常。
若是一個異常是能夠恢復的，能夠被調用者正確處理的，使用checked異常。
在使用unChecked異常時，必須在在方法聲明中詳細的說明該方法可能會拋出的unChekced異常。由調用者本身去決定是否捕獲unChecked異常
倒底何時使用checked異常，何時使用unChecked異常？並無一個絕對的標準。可是筆者能夠給出一些建議
當全部調用者必須處理這個異常，可讓調用者進行重試操做；或者該異常至關於該方法的第二個返回值。使用checked異常。
這個異常僅是少數比較高級的調用者才能處理，通常的調用者不能正確的處理。使用unchecked異常。有能力處理的調用者能夠進行高級處理，通常調用者乾脆就不處理。
這個異常是一個很是嚴重的錯誤，如數據庫鏈接錯誤，文件沒法打開等。或者這些異常是與外部環境相關的。不是重試能夠解決的。使用unchecked異常。由於這種異常一旦出現，調用者根本沒法處理。
若是不能肯定時，使用unchecked異常。並詳細描述可能會拋出的異常,以讓調用者決定是否進行處理。
3．  設計一個新的異常類
在設計一個新的異常類時，首先看看是否真正的須要這個異常類。通常狀況下儘可能不要去設計新的異常類，而是儘可能使用java中已經存在的異常類。 
如

 
 
 
 

 

 

  
  
  
  
  

 

  
  java 代碼 

 



 
 
 
 

 

 

  
  
  
  
  

 
 
 
  
     
   
  1.  IllegalArgumentException, UnsupportedOperationException  
    2.
無論是新的異常是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應該繼續往上拋出。一個辦法是把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的產生。這樣纔不使異常信息丟失。
因此咱們在定義一個新的異常類時，必須提供這樣一個能夠包含嵌套異常的構造函數。並有一個私有成員來保存這個「原由異常」。
java 代碼
  1. public Class ExceptionB extends Exception{
  2. private Throwable cause;
  4. public ExceptionB(String msg, Throwable ex){
  5. super(msg);
  6. this.cause = ex;
  7. }
  9. public ExceptionB(String msg){
  10. super(msg);
  11. }
  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. }
  7. public NestedException(String msg, Throwable ex){
  8. super(msg);
  9. This.cause = ex;
  10. }
  12. public Throwable getCause(){
  13. return (this.cause ==null ?this :this.cause);
  14. }
  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);
  28. }else{
  29. ps.println(this);
  30. getCause().printStackTrace(ps);
  31. }
  32. }
  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. }
一樣要設計一個unChecked異常類也與上面同樣。只是須要繼承RuntimeException。
4．  如何記錄異常
做爲一個大型的應用系統都須要用日誌文件來記錄系統的運行，以便於跟蹤和記錄系統的運行狀況。系統發生的異常理所固然的須要記錄在日誌系統中。
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. }
  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. }
捕獲到一個未記錄過的異常或外部系統異常時，應該記錄異常的詳細信息
java 代碼
  1. try{
  2. ……
  3. String sql=」select * from userinfo」;
  4. Statement s = con.createStatement();
  5. ……
  6. Catch(SQLException sqlEx){
  7. Logger.error(「sql執行錯誤」+sql+sqlEx);
  8. }
究竟在哪裏記錄異常信息，及怎麼記錄異常信息，多是見仁見智的問題了。甚至有些系統讓異常類一記錄異常。當產生一個新異常對象時，異常信息就被自動記錄。
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());
  12. }
  13. public BusinessException(String s) {
  14. super(s);
  15. race();
  16. }
這彷佛看起來是十分美妙的，其實必然致使了異常被重複記錄。同時違反了「類的職責分配原則」，是一種很差的設計。記錄異常不屬於異常類的行爲，記錄異常應該由專門的日誌系統去作。而且異常的記錄信息是不斷變化的。咱們在記錄異常同應該給更豐富些的信息。以利於咱們可以根據異常信息找到問題的根源，以解決問題。
雖然咱們對記錄異常討論了不少，過多的強調這些反而使開發人員更爲疑惑，一種好的方式是爲系統提供一個異常處理框架。由框架來決定是否記錄異常和怎麼記錄異常。而不是由普通程序員去決定。可是瞭解些仍是有益的。
5． J2EE項目中的異常處理
目前,J2ee項目通常都會從邏輯上分爲多層。比較經典的分爲三層：表示層，業務層，集成層(包括數據庫訪問和外部系統的訪問)。
J2ee項目有着其複雜性，J2ee項目的異常處理須要特別注意幾個問題。
在分佈式應用時，咱們會遇到許多checked異常。全部RMI調用（包括EJB遠程接口調用）都會拋出java.rmi.RemoteException;同時RemoteException是checked異常，當咱們在業務系統中進行遠程調用時，咱們都須要編寫大量的代碼來處理這些checked異常。而一旦發生RemoteException這些checked異常對系統是很是嚴重的，幾乎沒有任何進行重試的可能。也就是說，當出現RemoteException這些可怕的checked異常，咱們沒有任何重試的必要性，卻必需要編寫大量的try…catch代碼去處理它。通常咱們都是在最底層進行RMI調用，只要有一個RMI調用，全部上層的接口都會要求拋出RemoteException異常。由於咱們處理RemoteException的方式就是把它繼續往上拋。這樣一來就破壞了咱們業務接口。RemoteException這些J2EE系統級的異常嚴重的影響了咱們的業務接口。咱們對系統進行分層的目的就是減小系統之間的依賴，每一層的技術改變不至於影響到其它層。
java 代碼
  1. //
  2. public class UserSoaImplimplements 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異常。
爲了不繫統級的checked異常對業務系統的深度侵入，咱們能夠爲業務方法定義一個業務系統本身的異常。針對像SQLException,RemoteException這些很是嚴重的異常，咱們能夠新定義一個unChecked的異常，而後把SQLException，RemoteException封裝成unChecked異常後拋出。
若是這個系統級的異常是要交由上一級調用者處理的，能夠新定義一個checked的業務異常，而後把系統級的異常封存裝成業務級的異常後再拋出。
通常地，咱們須要定義一個unChecked異常，讓集成層接口的全部方法都聲明拋出這unChecked異常。
java 代碼
  1. public DataAccessExceptionextends RuntimeException{
  2. ……
  3. }
  4. public interface UserDao{
  5. public String getPassword(String userId)throws DataAccessException;
  6. }
  8. public class UserDaoImplimplements 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(「數據庫查詢失敗」+sql,ex);
  18. }
  19. }
  20. }
定義一個checked的業務異常，讓業務層的接口的全部方法都聲明拋出Checked異常.
java 代碼
  1. public class BusinessExceptionextends Exception{
  2. …..
  3. }
  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表示層應該是一個很薄的層，主要的功能爲：得到頁面請求，把頁面的參數組裝成POJO對象，調用相應的業務方法，而後進行頁面轉發，把相應的業務數據呈現給頁面。表示層須要注意一個問題，表示層須要對數據的合法性進行校驗，好比某些錄入域不能爲空，字符長度校驗等。
J2ee從頁面全部傳給後臺的參數都是字符型的，若是要求輸入數值或日期類型的參數時，必須把字符值轉換爲相應的數值或日期值。
若是表示層代碼校驗參數不合法時，應該返回到原始頁面，讓用戶從新錄入數據，並提示相關的錯誤信息。
一般把一個從頁面傳來的參數轉換爲數值，咱們能夠看到這樣的代碼
java 代碼
  1. ModeAndView handleRequest(HttpServletRequest request,HttpServletResponse response)throws Exception{
  2. String ageStr = request.getParameter(「age」);
  3. int age = Integer.parse(ageStr);
  4. …………
  6. String birthDayStr = request.getParameter(「birthDay」);
  7. SimpleDateFormat format = new SimpleDateFormat(「MM/dd/yyyy」);
  8. Date birthDay = format.parse(birthDayStr);
  10. }
上面的代碼應該常常見到，可是當用戶從頁面錄入一個不能轉換爲整型的字符或一個錯誤的日期值。
Integer.parse()方法被拋出一個NumberFormatException的unChecked異常。可是這個異常絕對不是一個致命的異常,通常當用戶在頁面的錄入域錄入的值不合法時，咱們應該提示用戶進行從新錄入。可是一旦拋出unchecked異常，就沒有重試的機會了。像這樣的代碼形成大量的異常信息顯示到頁面。使咱們的系統看起來很是的脆弱。
一樣，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」,」不是合法的整數值」);
  10. }
  11. …………
  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. }
  20. }
在表示層必定要弄清楚調用方法的是否會拋出unChecked異常，什麼狀況下會拋出這些異常，並做出正確的處理。
在表示層調用系統的業務方法，通常狀況下是無須要捕獲異常的。若是調用的業務方法拋出的異常至關於第二個返回值時，在這種狀況下是須要捕獲
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程