I have a try/catch block where I catch all Throwable exceptions.
try {
...
} catch (Throwable $ex) {
...
}
How do I, at runtime, figure out what the exact class of the throw exception is? I want to add multiple catch blocks to handle different exceptions differently, but am unable to find out the types of exceptions that are thrown.
Try to dump get_class($ex) inside your catch block. It will give you the class name of $ex.
After the class name is found, you can use catch with exact class exception.
Related
Suppose I have a repository class, a service class, and finally a controller class.
Now, I have a repository class that uses PDO, and I enclosed the execution into a try-catch block, example, below:
MyRepository {
public function someRepositoryFunction()
{
try {
...some pdo execution
} catch (PDOException $e) {
throw new PDOException($e->getMessage());
}
}
}
My question is, when I call that someRepositoryFunction() in the Service class, do I have to enclose it in a try-catch block also? example, below:
MyService {
public function someServiceFunction()
{
$repo = new MyRepository();
try {
$repo->someRepositoryFunction();
} catch (PDOException $e) {
throw new PDOException($e->getMessage());
}
}
}
and finally, when I call the Service class in the Controller, do I also have to enclose the someServiceFunction() in a try-catch block?
Or, catching it in the Repository class enough?
When you catch an Exception, you got 2 options, manage the Exception right were you caught it, according to your app logic or needs or you can throw the exception again and propagate this Exception.
In your case you are throwing the exception again, so you need to catch it again in whatever place you called the method and if you keep throwing the exception up you have to keep catching it.
As we all konwn,PHP have a class named "Exception"to handle the unexcepting situation.I usually find that someone like self-define a new exception class which extend the class "Exception". This new exception class do not rewrite or add any function.It just state a children class of the class "Exception".
so,I doubt that if it is necessary self-define a new Exception class in my project?In the past,I used the class "Exception" in anywhere.
It is not necessary, but it might be very convenient: If you have different kinds of exceptions, you can handle them differently when you catch them:
try {
...
} catch (SpecificException $e) {
// Do something specific here
} catch (SomeOtherException $e) {
// Here you can do something else
} catch (\Exception $e) {
// The rest...
}
The main reason to define an exception in that way is to help with debugging and error handling. Not only is something like NetworkException more informative, but you can also catch that type of exception when it occurs, so you can deal with different types of exceptions in different ways. Some may be temporary, so you might catch them and ask the user to try again later, for instance.
I want to catch a specific Exception and handle it properly. However, I have not done this before and I want to do it in the best way.
Will it be correct to create a separate class something like
class HandleException extends Exception
{
//my code to handle exceptions;
}
and in it have different methods handling the different exception cases? As far as I understand, the Exception class is like an "integrated" class in php so it can be extended and if an Exception is caught it is not obligatory to terminate the flow of the program?
And, an instance of this class will be created when an exception is caught? Sth. like
catch ( \Exception $e ) {
$error = new HandleException;
}
You CAN extend the basic Exception object with your own, to provide your own exception types, e.g.
class FooExcept extends Exception { .... }
class BarExcept extends Exception { .... }
try {
if ($something) {
throw new FooExcept('Foo happened');
} else if ($somethingelse) {
throw new BarExcept('Bar happened');
}
} catch (FooExcept $e) {
.. foo happened, fix it...
} catch (BarExcept $e) {
... bar happened, fix it ...
}
If an Exception is caught, then the program DOESN'T necessarily have to abort. That'd be up to the exception handler itself. But if an exception bubbles always back up to the top of the call stack and ISN'T caught, then the entire script will abort with an unhandled exception error.
From the manual
Multiple catch blocks can be used to catch different classes of
exceptions. Normal execution (when no exception is thrown within the
try block) will continue after that last catch block defined in
sequence. Exceptions can be thrown (or re-thrown) within a catch
block.
So you can do something like this:
try {
// some code
} catch ( HandleException $e ) {
// handle sthis error
} catch ( \Exception $e ) {
// handle that error
}
This will handle different exceptions. You can also use the finally keyword with newer versions of PHP.
I am Studying about Exceptions At W3schools At this Link, inside the link just before the heading:
"Re-throwing Exceptions"
there is a sentence that say:
"If the exception thrown were of the class customException and there
were no customException catch, only the base exception catch, the
exception would be handled there."
If can someone please give me an example for this sentence i will be very thankful.
Basically they're saying if you don't have a catch statement set up to catch customException it will fall through to the general Exception catch statement.
In this example, the first catch statement will catch customException because it explicitly is designed to do so.
try {
// fail
throw new customException();
}
catch (customException $e) {
// catch custom exception
}
catch (Exception $e) {
// catch any uncaught exceptions
}
In the next example, because that clause it missing the generic Exception catch block will catch it instead:
try {
// fail
throw new customException();
}
catch (Exception $e) {
// catch any uncaught exceptions
}
Take a look at Example #2 on this page of the PHP manual
And w3schools isn't the best place to learn PHP, it's (in)famous for its errors
Say you have a custom exception defined as
class CustomException extends Exception.
Now somewhere in your code:
try
{
// do something that throws a CustomException
}
catch(Exception $e) // you are only catching Exception not CustomException,
// because there isn't a specific catch block for CustomException, and
// because Exception is a supertype of CustomException, the exception will
// still be caught here.
{
echo 'Message: ' .$e->getMessage();
}
So what it means is that because CustomException is a subclass of Exception, as long as you catch the Exception type of the superclass without a catch block for the more specific sub class type, it will still be caught
There are two catch blocks in the example. The first catches only customException; the next one catches any Exception. If the first block catches anything, you never get to the second block. But since a customException is also an example of an Exception, it would have gotten caught there if we didn't have the first catch block. This way, the first catch catches it, and the execution never reaches the second.
In the meantime, read the link I posted above, and why w3schools is a bad idea.
In some libraries it is common practice to make custom Exception classes for every error condition, like:
class FileNotFound_Exception extends Exception {}
You can handle certain type of Exception, however you cannot read all source code of all libraries to remember each Exception class, and cannot take full advantage of using custom Exceptions. Most of time I just catching them with base Exception class:
catch (Exception $e)
{
// log and display friendly error
}
Is there other ways to have benefit of custom Exception classes, without writing long list of catch blocks?
I like Exceptions, but don't know how to use them properly. Thank you.
The benefit of having your own Exception class is that you, as the author of the library, can catch it and handle it.
try {
if(somethingBadHappens) {
throw MyCustomException('msg',0)
}
} catch (MyCustomException $e) {
if(IcanHandleIt) {
handleMyCustomException($e);
} else {
//InvalidArgumentException is used here as an example of 'common' exception
throw new InvalidArgumentException('I couldnt handle this!',1,$e);
}
}
Well, custom exception classes lets you route your errors properly for better handling.
if you have a class
class Known_Exception extends Exception {}
and a try catch block like this:
try {
// something known to break
} catch (Known_Exception $e) {
// handle known exception
} catch (Exception $e) {
// Handle unknown exception
}
Then you know that Exception $e is an unknown error situation and can handle that accordingly, and that is pretty useful to me.