Exempel på att hantera fel: programmet CustomErrors

När programmet läses in anropas metoden initApp() för Flex-program eller så körs tidslinjekoden (icke-funktion) för Flash Professional-program. Den här koden definierar XML-paketet som ska verifieras av klassen Validator. Följande kod körs:

employeeXML =  
    <employee id="12345"> 
        <firstName>John</firstName> 
        <lastName>Doe</lastName> 
        <costCenter>12345</costCenter> 
        <costCenter>67890</costCenter> 
    </employee>; 
}

XML-paketet visas senare i en TextArea-komponentinstans på scenen. Detta gör att du kan ändra XML-paketet innan du försöker omvalidera det.

När användaren klickar på knappen Validate anropas metoden validateData(). Den här metoden validerar XML-paket för employee med hjälp av metoden validateEmployeeXML() i klassen Validator. I följande exempel visas metoden validateData():

function validateData():void 
{ 
    try 
    { 
        var tempXML:XML = XML(xmlText.text); 
        Validator.validateEmployeeXML(tempXML); 
        status.text = "The XML was successfully validated."; 
    } 
    catch (error:FatalError) 
    { 
        showFatalError(error); 
    } 
    catch (error:WarningError) 
    { 
        showWarningError(error); 
    } 
    catch (error:Error) 
    { 
        showGenericError(error); 
    } 
}

Till att börja med skapas ett temporärt XML-objekt med hjälp av innehållet i TextArea-komponentinstansen xmlText. Därefter anropas metoden validateEmployeeXML() i den anpassade Validator-klassen (com.example.programmingas3/errors/Validator.as) och det temporära XML-objektet skickas som en parameter. Om XML-paketet är giltigt visas i Label-komponentinstansen status ett meddelande om att det lyckades och programmet avslutas. Om metoden validateEmployeeXML() orsakar ett eget fel (d.v.s. att ett FatalError, WarningError eller allmänt Error inträffar), körs rätt catch-sats och någon av metoderna showFatalError(), showWarningError() eller showGenericError() anropas. Dessa metoder visar ett meddelande i ett textområde med namnet statusTex för att meddela användaren att ett speciellt fel har inträffat. Metoderna uppdaterar dessutom Label-komponentinstansen status med ett speciellt meddelande.

Om ett allvarligt fel inträffar under ett försök att validera XML-paketet för employee, visas felmeddelandet i textområdet statusText, och TextArea-komponentinstansen xmlText och Button-komponentinstansen validateBtn visas, vilket framgår av exemplet nedan:

function showFatalError(error:FatalError):void 
{ 
    var message:String = error.message + "\n\n"; 
    var title:String = error.getTitle(); 
    statusText.text = message + " " + title + "\n\nThis application has ended."; 
    this.xmlText.enabled = false; 
    this.validateBtn.enabled = false; 
    hideButtons(); 
}

Om det i stället för ett allvarligt fel inträffar en varning, visas felmeddelandet i TextArea-instansen statusText, men varken TextField- eller Button-komponentinstansen xmlText visas. Metoden showWarningError() visar det anpassade felmeddelandet i textområdet statusText. I meddelandet kan dessutom användaren bestämma om han/hon vill fortsätta valideringen av XML-skriptet eller avbryta det. I följande utdrag visas metoden showWarningError():

function showWarningError(error:WarningError):void 
{ 
    var message:String = error.message + "\n\n" + "Do you want to exit this application?"; 
    showButtons(); 
    var title:String = error.getTitle(); 
    statusText.text = message; 
}

När användaren klickar på knappen Yes eller No anropas metoden closeHandler(). I följande utdrag visas metoden closeHandler():

function closeHandler(event:CloseEvent):void 
{ 
    switch (event.detail) 
    { 
        case yesButton: 
            showFatalError(new FatalError(9999)); 
            break; 
        case noButton: 
            statusText.text = ""; 
            hideButtons(); 
            break; 
    } 
}

Om användaren väljer att avbryta skriptet genom att klicka på Yes uppstår ett allvarligt fel som leder till att programmet stängs ner.

Klassen Validator innehåller metoden validateEmployeeXML(). Metoden validateEmployeeXML() tar ett enda argument, employee, vilket är det XML-paket som du vill validera. Metoden validateEmployeeXML() har följande utseende:

public static function validateEmployeeXML(employee:XML):void 
{ 
    // checks for the integrity of items in the XML 
    if (employee.costCenter.length() < 1) 
    { 
        throw new FatalError(9000); 
    } 
    if (employee.costCenter.length() > 1) 
    { 
        throw new WarningError(9001); 
    } 
    if (employee.ssn.length() != 1) 
    { 
        throw new FatalError(9002); 
    } 
}

För att kunna valideras måste en ”employee” tillhöra ett (och endast ett) ”cost center”. Om ”employee” inte tillhör ett ”cost center” resulterar metoden i ett allvarligt fel, som bubblar upp till metoden validateData() i programmets huvudfil. Om "employee" tillhör flera "cost center" uppkommer ett varningsfel. Den sista kontrollen i XML-validatorn är att användaren har endast ett socialförsäkringsnummer definierat (noden ssn i XML-paketet). Om det inte finns exakt en ssn-nod uppstår ett allvarligt fel.

Du kan lägga till fler kontroller för metoden validateEmployeeXML(), om du till exempel vill kontrollera att ssn-noden innehåller ett giltigt nummer eller att medarbetaren har angett minst ett telefonnummer och en e-postadress och att båda värdena är giltiga. Du kan också ändra XML-koden så att varje ”employee” har ett unikt ID och ange ett ID för deras chef.

Klassen ApplicationError fungerar som huvudklass för både klassen FatalError och klassen WarningError. Klassen ApplicationError utökar klassen Error och definierar egna metoder och egenskaper, inklusive ett fel-ID, hur allvarligt felet är och ett XML-objekt som innehåller anpassade felkoder och meddelanden. Den här klassen definierar också två statiska konstanter som används för att definiera hur allvarlig varje feltyp är.

Konstruktormetoden för klassen ApplicationError har följande utseende:

public function ApplicationError() 
{ 
    messages =  
        <errors> 
            <error code="9000"> 
                <![CDATA[Employee must be assigned to a cost center.]]> 
            </error> 
            <error code="9001"> 
                <![CDATA[Employee must be assigned to only one cost center.]]> 
            </error> 
            <error code="9002"> 
                <![CDATA[Employee must have one and only one SSN.]]> 
            </error> 
            <error code="9999"> 
                <![CDATA[The application has been stopped.]]> 
            </error> 
        </errors>; 
}

Varje felnod i XML-objektet innehåller en unik nummerkod och ett felmeddelande. Felmeddelandet kan slås upp med hjälp av felkoden och E4X, vilket framgår i följande getMessageText()-metod:

public function getMessageText(id:int):String 
{ 
    var message:XMLList = messages.error.(@code == id); 
    return message[0].text(); 
}

Metoden getMessageText() tar ett enskilt heltalsargument, id, och returnerar en sträng. Argumentet id är en felkod för felet som ska slås upp. Om id 9001 skickas hämtas felet som anger att ”employee” endast ska vara tilldelad till ett ”cost center”. Om flera fel har samma felkod, returnerar ActionScript endast det första felmeddelandet (message[0] i det returnerade XMLList-objektet).

Nästa metod i den här klassen, getTitle(), tar inga parametrar och returnerar ett strängvärde som innehåller ID:t för det aktuella felet. Detta värde används för att hjälpa dig att identifiera det exakta felet som inträffade under valideringen av XML-paketet. I följande utdrag visas metoden getTitle():

public function getTitle():String 
{ 
    return "Error #" + id; 
}

Den sista metoden i klassen ApplicationError är toString(). Den här metoden åsidosätter den funktion som definieras i klassen Error så att du kan anpassa presentationen av felmeddelandet. Metoden returnerar en sträng som identifierar det specifika felnumret och meddelandet.

public override function toString():String 
{ 
    return "[APPLICATION ERROR #" + id + "] " + message; 
}

Klassen FatalError utökar den egna klassen ApplicationError och definierar tre metoder: FatalError-konstruktorn, getTitle() och toString(). Den första metoden, FatalError-konstruktorn, tar ett heltalsargument, errorID, och ställer in hur allvarligt felet är med hjälp av statiska konstantvärden som definieras i klassen ApplicationError, och erhåller det specifika felets felmeddelande genom att anropa metoden getMessageText() i klassen ApplicationError. FatalError-konstruktorn har följande utseende:

public function FatalError(errorID:int) 
{ 
    id = errorID; 
    severity = ApplicationError.FATAL; 
    message = getMessageText(errorID); 
}

Nästa metod i klassen FatalError, getTitle(), åsidosätter metoden getTitle(), som definierades tidigare i klassen ApplicationError, och lägger till texten ”-- FATAL” i titeln för att informera användaren om att ett allvarligt fel har inträffat. Metoden getTitle() har följande utseende:

public override function getTitle():String 
{ 
    return "Error #" + id + " -- FATAL"; 
}

Den sista metoden i den här klassen, toString(), åsidosätter metoden toString() som definierades i klassen ApplicationError. Metoden toString() har följande utseende:

public override function toString():String 
{ 
    return "[FATAL ERROR #" + id + "] " + message; 
}

Klassen WarningError utökar klassen ApplicationError och är näst intill identisk med klassen FatalError, med undantag av några strängförändringar och att den ställer in felets svårighetsgrad till ApplicationError.WARNING i stället för ApplicationError.FATAL, vilket framgår av följande kod:

public function WarningError(errorID:int) 
{ 
    id = errorID; 
    severity = ApplicationError.WARNING; 
    message = super.getMessageText(errorID); 
}