public class EncryptionException extends L10NMessageImpl
This class is the super-class for all Federation checked exceptions.
Some Exception throwing guidelines:
-------------------------------------
Checked exceptions are sub-classes of java.lang.Exception; methods
throwing this type of exception are forced to define a throws clause
in the method signature and client programmers need to catch and
handle the exception with a try/catch block or declare the throws clause
in their methods.
Unchecked exceptions are sub-classes of java.lang.RuntimeException.
Client programmers don't have to deal with the exception using a
try/catch block and the method throwing it does not have to define it
in its signature.
- If your method encounters an abnormal condition which causes it
to be unable to fulfill its contract, or throw a checked or
unchecked exception (either EncryptionException or RuntimeException).
- If your method discovers that a client has breached its contract,
for example, passing a null as a parameter where a non-null value is
required, throw an unchecked exception (RuntimeException).
- If your method is unable to fulfill its contract and you feel client
programmers should consciously decide how to handle, throw checked
exceptions (EncryptionException).
Embedded/Nested Exceptions:
--------------------------
An exception of type EncryptionException can embed any
exception of type Throwable. Embedded exceptions ensure traceability
of errors in a multi-tiered application. For example, in a simple 3-
Tier model - presentation/client tier, middle/domain tier and
database/persistence tier - the real cause of error might be lost by the
time control, which is passed back from the persistence tier to the client
tier. To ensure tracking info, the constructor EncryptionException(message,Throwable)
should be used while throwing the exception.
Client programs can then invoke the #getRootCause() method
to get the underlying cause.
Exception hierarchy should be defined:
-------------------------------------
An exception for each abnormal cause should be created.
EncryptionException should probably be thrown only by external API's.
Even these should have embedded exceptions from lower level tiers.
Every package should define its own exception hierarchies specific
to its context, for example, account management exceptions should be
defined in the accountmgmt package.
Localizing Error Messages
-------------------------
The java resource bundle mechanism is used to implement localization.
The ResourceSet and ResourceSetManager classes are used to implement
localization.
Steps for creating EncryptionException Sub-classes and messages
------------------------------------------------------
1. Identify the package this exception will belong to.
account management related exception
should be part of the accountmgmt package.
2. Each package should have its own properties file to store
error messages.
For example accountmgmt.properties in package accountmgmt
3. Create a sub-class of EncryptionException and override the constructors.
public class FSAccountManagementException extends EncryptionException {
public FSAccountManagementException() {
super();
}
public FSAccountManagementException(String msg) {
super(msg);
}
public FSAccountManagementException(String msg, Throwable t) {
super(msg,t);
}
Throwing/Catching Exception Examples:
------------------------------------
1. Throwing a non-nested Exception
(not recommended, use Ex. 3 below)
EncryptionException ux = new EncryptionException("Some weird error!...");
throw ux;
2. Throwing a nested Exception
(not recommended, use Ex. 3 below)
try {
.......
.......
} catch (UMSException umse) {
EncryptionException fse =
new EncryptionException("Some weird error!...", le);
throw ux;
}
3. Throwing an Exception using the ResourceSetManager
- Logging/Dealing with an Exception, inclunding all nested exceptions
try {
.......
.......
} catch (EncryptionException fse) {
if (fse.getRootCause() instanceof UMSException) {
PrintWriter pw = new PrintWriter();
fse.log(pw);
} else {
System.out.println(fse.getMessage());
}
}
| Modifier and Type | Field and Description |
|---|---|
protected String |
_message |
protected Throwable |
rootCause |
| Constructor and Description |
|---|
EncryptionException(Exception ex) |
EncryptionException(String message)
Constructs a
EncryptionException with a detailed message. |
EncryptionException(String errorCode,
Object[] args)
Constructor
|
EncryptionException(String errorCode,
Object[] args,
Throwable rootCause)
Constructor
|
EncryptionException(Throwable rootCause,
String message)
Constructs a
EncryptionException with a message and
an embedded exception. |
| Modifier and Type | Method and Description |
|---|---|
Throwable |
getRootCause()
Returns the embedded exception.
|
PrintWriter |
log(PrintWriter out)
Format this
EncryptionException to a PrintWriter. |
static PrintWriter |
log(Throwable xcpt,
PrintWriter out)
A utility method to format an Exception to a
PrintWriter. |
void |
printStackTrace()
Prints this exception's stack trace to System.err.
|
void |
printStackTrace(PrintStream ps)
Prints this exception's stack trace to a print stream.
|
void |
printStackTrace(PrintWriter pw)
Prints this exception's stack trace to a print writer.
|
String |
toString()
Returns a formatted
EncryptionException exception message;
includes embedded exceptions. |
getErrorCode, getL10NMessage, getMessage, getMessageArgs, getResourceBundleNameaddSuppressed, fillInStackTrace, getCause, getLocalizedMessage, getStackTrace, getSuppressed, initCause, setStackTracepublic EncryptionException(String errorCode, Object[] args)
errorCode - Key of the error message in resource bundle.args - Arguments to the message.public EncryptionException(String errorCode, Object[] args, Throwable rootCause)
errorCode - Key of the error message in resource bundle.args - Arguments to the message.rootCause - An embedded exceptionpublic EncryptionException(String message)
EncryptionException with a detailed message.message - Detailed message for this exception.public EncryptionException(Throwable rootCause, String message)
EncryptionException with a message and
an embedded exception.message - Detailed message for this exception.rootCause - An embedded exceptionpublic EncryptionException(Exception ex)
public Throwable getRootCause()
public PrintWriter log(PrintWriter out)
EncryptionException to a PrintWriter.out - PrintWriter to write exception to.PrintWriterpublic static PrintWriter log(Throwable xcpt, PrintWriter out)
PrintWriter.xcpt - Exception to log.out - PrintWriter to write exception to.PrintWriterpublic String toString()
EncryptionException exception message;
includes embedded exceptions.public void printStackTrace()
printStackTrace in class Throwablepublic void printStackTrace(PrintStream ps)
printStackTrace in class Throwableps - The non-null print stream to which to print.public void printStackTrace(PrintWriter pw)
printStackTrace in class Throwablepw - The non-null print writer to which to print.Copyright © 2010–2025 Open Identity Platform Community. All rights reserved.