programmera.net -> jsp -> normal     för utskrift      info@programmera.net

Undantag i webb-behållaren

1. Undantag
2. Undantag i webb-behållaren
3. Generera ett fel
4. Hemmagjord felsida
5. Ett exempel på felhantering
6. Bönan MyErrorGenerator
7. JSP-sidorna
8. Testa felsidan
9. 404 - file not found

1. Undantag

Undantag besrkivs på sidan  java/undantag , men här ges en kort repetition. I java gör man skillnad på fel och undantag:

  • Fel (klassen Error): Något allvarligt fel som inte har med användaren att göra, felet ska inte fångas utan avslutar applikationen omedlebart. Ett exempel på denna typ av fel är när OutOfMemoryError.
  • Undantag: Ett mindre allvarligt fel som inte nödvändigtvis krashar hela applikationen. Alla undantag är subklasser av throwable, vilket betyder att ett undantag kan fångas och hanteras av programmet. Det finns två typer av undantag:
    • Klassen Exception: Denna typ av undantag kan bara inträffa inuti ett try-block. Försöker man använda en metod som kastar denna typ av undantag utanför ett try-block kommer kompilatorn att protestera. Exempel på denna typ av fel är FileNotFoundException och IOException.
    • Klassen RuntimeException: Denna typ av undantag kan inträffa utanför ett try-block. De behöver alltså inte fångas. Om de inte fångas avbryter de exekveringen av servleten. Ett typiskt fel är NullPointerException eller ArrayIndexOutOfBoundsException.

2. Undantag i webb-behållaren

Förutom Error kan en servlet kan kasta följande undantag vid körning:

  • Subklasser till RuntimeException.
  • IOException och dess subklasser.
  • ServletException och dess subklasser.
ServletException kan bara inträffa i en servlet, men de andra undantagen är välbekanta från Java. Undantagsrapportering i webb-behållaren fungerar ungufär som för ett vanligt Javaprogram:
  • Vanligt Javaprogram: Då ett undantag som inte fångas inträffar abryts programmet och StackTrace skrivs ut i terminalfönstret.
  • Java i Webb-behållaren: Då ett undantag som inte fångas inträffar i en servlet avbryts servleten, och ett HTTP-svar autogenereras med felkoden 500. HTTP-svaret innehåller utskriften StackTrace.
StackTrace är vad som skrivs ut på terminalen vid ett anrop till exception.printStackTrace().

3. Generera ett fel

Skapa sidan myoutofbounds.jsp: 
<HTML>
<BODY>
<H1>My Out Of Bounds</H1>
Denna sida genererar ett fel:
<% 
int ar[]={3,4,5};
int x;
x=ar[9];

%>
<BR/>x=<%=x %>
</BODY>
</HTML>
Spara sidan till webbroten CATALINA_HOME/programmera/myoutofbounds.jsp. När du försöker titta på sidan i webbläsaren ser du:



Denna sida genereras automatiskt av webb-behållaren.

4. Hemmagjord felsida

Många tycker att den webbsida som autogenereras av webb-behållaren inte är speciellt informativ för användarna som normalt använder webbapplikationen. Istället skriver man en egen felsida med samma "look and feel" som företagets övriga webbplats. Sedan gäller det att få denna felsida att anropas då fel inträffar, det finns två sätt att åstakomma detta:

  • I web.xml kan man med märket error-page se till att en viss felsida skickas då ett speciellt undantag inträffar. Denna inställning gäller för alla JSP-sidor i webbapplikationen.
  • Med direktivet page errorPage kan man bestämma vilken sida man ska hoppa till vid fel. Denna inställning gäller bara för den aktuella JSP-sidan. Denna inställning slår över alla eventuella inställningar i web.xml.

5. Ett exempel på felhantering

Nu ska vi göra ett exempel som består av följande delar:

  1. En böna MyErrorGenerator.class som alltid genererar ett RuntimeException då den används.
  2. En JSP-sida myerror.jsp som anropar bönan.
  3. En JSP-sida exception.jsp som ska visas då felet inträffar.
Vi skulle kunna generera felet direkt i sidan myerror.jsp, men vi vill visa att fel som inträffar utanför JSP-sidor även omdirigeras till vår hemmagjorda felsida.

6. Bönan MyErrorGenerator

Skapa en fil med följande innehåll: 
package nu.programmera;

public class MyErrorGenerator{
   public void generate(){
      int array[]={1,3,5,3};
      int x;
      x=array[90]; // Generates ArrayIndexOutOfBoundsException
   }	
}
Spara till sökvägen CATALINA_HOME/webapps/programmera/WEB-INF/classes/nu/programmera/MyErrorGenerator.java, och kompilera.

7. JSP-sidorna

Först skriver vi en webbsida som använder den felaktiga bönan MyErrorGenerator: 
<%@ page errorPage="/exceptions/exception.jsp" %>
<jsp:useBean id="meg" class="nu.programmera.MyErrorGenerator" scope="page" />
<HTML>
<BODY>
<H1>My Error</H1>
Denna sida anropar en böna som genererar ett undantag.
<BR/>NR=<%= meg.generate() %>
</BODY>
</HTML>
Vi döper denna sida till myerror.jsp och lägger den i webbroten CATALINA_HOME/programmera/. Nu ska vi skriva sidan exception.jsp som visas då ett undantag inträffar: 
<%@ page isErrorPage="true" %>
<HTML>
<BODY>
<H1>Problem på servern</H1>
Teamet bakom <B>programmera.nu</B> ber om ursäkt! Det har inträffat ett fel på servern.
Kontakta gärna support på <B>info@programmera.nu</B> för snabb service.
<BR/>
<BR/>Meddelande: <%= exception.toString() %> 
</BODY>
</HTML>
Spara denna sida till CATALINA_HOME/programmera/exceptions/exception.jsp.

8. Testa felsidan

Anropa myerror.jsp och du får se:

9. 404 - file not found

Då man anropar en sida på webbplatsen som inte finns får man en autogenererad 404-sida av servern. 404 är en kod i HTTP som betyder att den sökta resursen inte kan hittas. Vi gör en egen 404-sida med följande utseende: 
<%@ page isErrorPage="true" %>
<HTML>
<BODY>
<H1>Den sida du söker finns inte!</H1>
Gå till förstasidan och försök igen..
</BODY>
</HTML>
Sparar den på sökvägen exceptions/404.jsp. För att sidan ska anropas måste vi ändra i web.xml, vi lägger till följande rader: 
<error-page>
  <error-code>404</error-code>
  <location>/exceptions/404.jsp</location>
</error-page>
Nu när vi testar att anropa en icke existerande sidan i vår applikation får vi: