当数据库Mysql崩溃时，如何在Java中知道

Question

I am using J2EE and a Mysql database and making a connection using JDBC. I want to know when the database crashes and how to handle it. Is it that the only way to check the database is to see if the connections establish successfully? Or there is other way?

Answer 1

You can't and shouldn't need to know. As far as your program is concerned, either everything works perfectly or you can't get a connection.

The program has to behave correctly if a connection can't be acquired, which in most cases probably involves some form of error display and ceasing of operations. Naturally you'll want to have some form of monitoring so that someone will know to check what's wrong with the database, but it's not your program's responsibility.

Answer 2

There are actually a lot of things that can go wrong in a database that might constitute a crash, a major failure or a partial failure. A table could get dropped by an admin, you could run out of space, etc, etc. These might allow you to get a connection or they might not.

It is probably going to be very difficult to distinguish between what constitutes a major failure (database down) and what is a partial failure that might allow the system to continue.

Obviously, if you can't connect to the database, you can't do much with your application. That might indicate the database has "crashed", but it could also be a network problem if your database in on another server. It doesn't really matter.

Most applications that I have worked on don't do much in terms of checking for major failures. But there are a few of strategies that might help:

1. Have some "sanity checks" (eg, query a known table). If the sanity checks fail, you have a critical problem.
2. Have an error count. If more than a certain number of errors occurred in a given time, you have a critical problem.

Answer 3

How do I know in my Java code when my DB crashes?

As of JDBC 4.1 (JavaSE 7) there is the Connection.setNetworkTimeout(Executor, int) method which make JDBC operations cease execution and throw an SQLException if they take longer than the timeout you set.

To use this mechanism, set the network timeout to a number of milliseconds which you want to be the maximum amount of time you will wait to hear back from the DB. If any operations takes longer than the timeout you set, it will cease waiting and the method will throw an SQLException.

An example of how setNetworkTimeout could be used:

Connection conn = // get your connection however

conn.setNetworkTimeout(Executors.newSingleThreadExecutor(),
                       10 * 1000); // 10s timeout

Statement stmt = conn.createStatement();

// suppose DB crashes at this point in time

try {
    stmt.execute("SOME SQL HERE");
} catch (SQLException sqle) {
    // could be from network timeout,
    // but could also be caused by something else
    // You can check what your JDBC driver does
}

As you can see with this example, the fact that network timeouts only throw a SQLException makes the mechanism harder to work with. I really wish the architects of JDBC 4.1 had decided to require some subclass of SQLException be thrown so that there was a portable way of telling when a network timeout occurs. Something like SQLNetworkTimeoutException as a subclass of SQLException would have been nice.

In any case, your best bet for checking whether or not your SQLException was caused from a network timeout is by checking the message String on the SQLException , but be a bit careful doing this as different JDBC drivers will have different messages for network timeouts.

---

Another thing you could try in addition to or besides network timeout is checking for SQLNonTransientException . Typically the exception that will occur when there is some sort of catastrophic DB failure is the SQLNonTransientException which is the subclass of SQLException .

Essentially this exception means "something went wrong that is outside of the control of your code or the JDBC driver's" . So generally when you see this, it's because of a DB failure or network failure.

How do I handle a DB failure once I know something went wrong?

This part is a bit tricky, especially since so many things can go wrong with a DB (it could have crashed, the network could be down/slow, etc).

Option A: Show that something went wrong
In most cases I've seen, the way to "handle" this sort of failure is to acknowledge it and just present it to the user.

Option B: Retry and/or failover
Another option is doing a fixed number of retries and/or failing over to a backup database. Failing over to a backup db can be tricky, and typically this is only done if you have some sort of middleware do it for you.