Exception Management
The CFML language also provides you with a traditional approach to deal with error handling at the code block level. This is usually a trio of constructs:
try
: The try block allows you to demarcate the code to test if it fails or passes (https://cfdocs.org/cftry)finally
: The finally block executes no matter if the try fails or passes. It is guaranteed to always execute. (https://cfdocs.org/cffinally)
Basically, a try and catch statement attempts some code. If the code fails, CFML will do whatever is in the exception to try to handle it without breaking. Of course, many different types of exceptions can occur, which should sometimes be handled in a different manner than the others.
try{
// code to try to execute
} catch( any e ) {
// the any type catches ALL errors from the try above
} catch( myType e ){
// Catch the `myType` only type of exception
} finally {
// this code executes no matter what
}
The catch construct can take an
any
or a custom exception type declared by the CFML engine, Java code or custom exceptions within your code. This is a great way to be able to intercept for specific exception types and address them differently.try{
} catch( database e ){
} catch( template e ){
}
Some of the exception types found in CFML are the following
application
: catches application exceptionsdatabase
: catches database exceptionstemplate
: catches ColdFusion page exceptionssecurity
: catches security exceptionsobject
: catches object exceptionsmissingInclude
: catches missing include file exceptionsexpression
: catches expression exceptionslock
: catches lock exceptionsjava.lang.Exception
: catches Java object exceptionssearchengine
: catches Verity search engine exceptionsany
: catches all exception types
Custom exception types are defined by you the programmer and they can also be intercepted via their defined name. Let's say that the exception type is "
InvalidInteger
" then you can listen to it like this:try{
throw( type="invalidInteger" );
} catch ( "InvalidInteger" e ){
}
Now that you have seen how to listen to exceptions, let's discover the
throw
or cfthrow
constructs used to throw a developer-specific exception. (https://cfdocs.org/cfthrow)The
throw()
function or tag has several attributes:- Type : A custom or CFML core type
- Message : Describes the exception event
- Detail : A detailed description of the event
- errorCode : A custom error code
- extendedInfo : Custom extended information to send in the exception, can be anything
- object : Mutually exclusive with the other attributes, usually another exception object or a raw Java exception type.
try {
throw( message="Oops", detail="xyz", errorCode=12 );
} catch (any e) {
writeOutput( "Error: " & e.message);
} finally {
writeOutput( "I run even if no error" );
}
The
rethrow
or cfrethrow
construct allows you to well, rethrow
the active exception by preserving all of the exception information and types. Usually you use rethrow
within a catch block after you have done some type of operations on the incoming exception. (https://cfdocs.org/cfrethrow)try{
runAroundEachClosures( arguments.suite, arguments.spec );
} catch( any e ){
rethrow;
} finally {
runAfterEachClosures( arguments.suite, arguments.spec );
}
// Mix In Stub
try{
// include it
arguments.targetObject.$include = variables.$include;
arguments.targetObject.$include( instance.mockBox.getGenerationPath() & tmpFile );
structDelete( arguments.targetObject, "$include" );
// Remove Stub
removeStub( genPath & tmpFile );
} catch( any e ) {
// Remove Stub
removeStub( genPath & tmpFile);
rethrow;
}
Last modified 3yr ago