I have a Web Application that use Hibernate 3.0. When I restart my database server, is it always necessary to restart jboss server?
Can I reconnect to database without restart jboss server?
Depends on the pool configuration.
If you enable the "validate connection" checking, by passing a SQL to be executed before a connection is handled to the caller, your application will not get invalid connections. Meaning that the connection will be thrown out and a new one will be acquired in case the connection is broken. The price you pay for this, of course, is that you are doing a round-trip to the server.
But usually, you could leave this out and let the Exception sorter handle the case. In case JDBC problems are thrown by the Driver, this "Sorter" will analyse them and determine if the connection can be returned to the pool or not. I'm not sure about the MySQL implementation of the Exception Sorter, so, it might be worth trying. If it doesn't helps, you can always extend the existing sorter and add your logic to it.
Related
I am working on a service, where if there is any issue in the application, the request gets quarantined and can be reprocessed manually again after fixing the issue. If any network issue, such quarantined requests can be just processed again without any fix.
Now, I am working on a fix where the application failed to get DB Connectivity with MariaDB and got quarantined. As part of the quarantine, there are some meta data should be populated. One of the metadata is wrong and I have fixed to populate correct data.
I need to come up with JUnit test cases to automatically test this scenario. When I tested in my local, I brought down my local instance of the MariaDB and tested the same and my fix was working fine. Now I need to push this fix to stage environment, where automated test cases should run successfully. In my case, for this fix, I need to replicate the DB connectivity Issue scenario to test my issue fix.
The application/service that I work - it is not a direct http/https call. I post a message to a Kafka stream and the service picks up from the stream. So I need help in writing test case, where the DB connectivity issue should happen in the asynchronous service and gets quarantined. Is this possible?
Error:
"exception": "org.springframework.jdbc.CannotGetJdbcConnectionException",
"message": "Failed to obtain JDBC Connection; nested exception is java.sql.SQLNonTransientConnectionException: Could not connect to address=(host=localhost)(port=3306)(type=master) : Socket fail to connect to host
I would like to add some conditional logic to our Java application code for attempting to create a JMS Topic Connection. I have seen problems in the past stemming from attempting to create a connection when the MQ server had been restarted or was currently down. One improvement I added was to check for the quiescent state, and another was to increase the timer before attempting reconnection to our durable topic queue.
Is there a way to confirm with the MQ server/topic/channel that it is up and running and a connection request can safely be made?
The best way to confirm that a queue manager (and the channel you are using to connect to the queue manager) is up and running is to attempt to connect to it.
If your connection attempt fails, you will get an MQ Reason code telling you exactly why. This is a much better way to confirm than any administrative command, because it also confirms that your application, and it's security context is correct and able to connect to the queue manager. It is completely possible to have an up-and-running queue manager but an application that is not yet correctly configured to use it. So connect from the application and if it works, the queue manager is up-and-running.
Your comment about having an increased timer before attempting to reconnect after a failure is well made. It doesn't help anyone if you hammer the queue manager with lots of repeated and close together connection attempts until it is ready to accept your connection, but still anything that is going to test the availability of the queue manager needs to ultimately connect to it, so very simply, just connect.
I want to check if a JMS-Connection to a remote queuing is working. As this should be kind of J-Unit Test I can't use a Server (in my case would be Websphere. Is there any driver implementation or API I could use to initialize the connection ?
No; without a backend Queuemanager there's nothing to respond to the connection. Messaging is inherently a distributed / networked product. There isn't something like a 'mock' QueueManager. In order for the connection to be properly created the mock would need to implement a lot of real function.
Communicate with the database in java, we often follow these steps:
load a driver
get a connection
create a Statement or PreparedStatement
get the ResultSet
close the connection
I am confused that we should close connection, all say that create a connection is expensive, so why we can't do like this:
static
{
try
{
connection = DriverManager.getConnection(connectorURL,
user, password);
} catch (SQLException e)
{
e.printStackTrace();
}
}
We just create a connection as a singleton, and use it everywhere. Couldn't it? If I use it like this, what will happen?
And if I don't close the connection, what will happen?
Also, we will use a connection pool, it will create some connections in the pool, and we get the connection from the pool, the connection in the pool also don't close, why if we don't use pool, we need follow the steps and close the connection if we don't use?
It's so confused and I don't know the what's the principle. Please help me. Thanks.
If we don't close the connection, it will lead to connection memory leakage. Until application server/web server is shut down, connection will remain active, even if the user logs out.
There are additional reasons. Suppose database server has 10 connections available and 10 clients request for the connection. If the database sever grants all of them, and after their usage they are not closed, the database server would not be able to provide any other connection for another request. For that reason we need to close them - it is mandatory.
Furthermore, it might lead to some mischievous activities regarding the integrity of the database.
We just create a connection as a singleton, and use it everywhere. Couldn't it? If I use it like this, what will happen?
In this case, you will have only a single database connection. If database query is having a longer execution time, then other requests for that connection object will have to wait. So, this is not a recommended approach.
And if I don't close the connection, what will happen?
By closing the connection, objects of Statement and ResultSet will be closed automatically. The close() method is used to close the connection. If you forget to do so, it will lead your app to connection memory leak. For Example: Imagine that your app has 10 database connections and 10 users are active at the same time. Later on, 3 users log out of the app, but because you didn't implement connection closing mechanism, those 3 connections remain active, and as a result, your app will not provide any other connection to some other user. Also, increased number of opened connections, in database server, slows down the app. So, release the Connection object's database and JDBC resources immediately, instead of waiting for them to be automatically released.
Also, we will use a connection pool, it will create some connections in the pool, and we get the connection from the pool, the connection in the pool also don't close, why if we don't use pool, we need follow the steps and close the connection if we don't use?
Connection pooling means that connections are reused rather than created each time a connection is requested.
This source says, that: "If the system provides connection pooling, the lookup returns a connection from the pool if one is available. If the system does not provide connection pooling or if there are no available connections in the pool, the lookup creates a new connection. The application benefits from connection reuse without requiring any code changes. Reused connections from the pool behave the same way as newly created physical connections. The application makes a connection to the database and data access works in the usual way. When the application has finished its work with the connection, the application explicitly closes the connection.
The closing event on a pooled connection signals the pooling module to place the connection back in the connection pool for future reuse."
Your application borrows a connection from the pool, uses it, then returns it to the pool by closing it. A connection in the free pool for a long period of time is not considered an issue.
I'm using NHibernate and ODP.NET to connect to a Oracle 11g database. Of course there can be connection errors (network failure, DB down, ...). I'm handling all these exceptions in my code, so no problem there. But of course the user can retry his actions (maybe it was just a short network failure), and there comes my problem:
ODP.NET is using connection pooling by default. No problem with that usually, but when the user retries an action after a connection error, NHibernate gets an invalid (pooled) connection from ODP.NET. The user has to retry it multiple times (until the pool is empty) to get it working again.
Of course I can disable connection pooling in ODP.NET, but I'd like to avoid that. I've also read about a setting that checks the connection to the DB for each returned connection from the pool, but this adds an additional round trip to each connection which I'd like to avoid too.
Is there any way to configure ODP.NET to automatically clear the connection pool when any connection throws an connection exception?
If you can use odac (odp) 11g, you have setting Validate Connection for your pool. It can validate the connection before you use it.
The Validate Connection attribute validates connections coming out of the pool. This attribute should be used only when absolutely necessary, because it causes a round-trip to the database to validate each connection immediately before it is provided to the application. If invalid connections are uncommon, developers can create their own event handler to retrieve and validate a new connection, rather than using the Validate Connection attribute. This generally provides better performance.
If it will not be good enough - you can try this document from oracle.
Connection Pool Management
ODP.NET connection pool management provides explicit connection pool
control to ODP.NET applications. Applications can explicitly clear
connections in a connection pool.
Using connection pool management, applications can do the following:
Note: These APIs are not supported in a .NET stored procedure. Clear
connections from connection pools using the ClearPool method.
Clear connections in all the connection pools in an application
domain, using the ClearAllPools method.
When connections are cleared from a pool, ODP.NET repopulates the pool
with new connections that have at least the number of connections set
by Min Pool Size in the connection string. New connections do not
necessarily mean the pool will have valid connections. For example, if
the database server is down when ClearPool or ClearAllPools is called,
ODP.NET creates new connections, but these connections are still
invalid because they cannot connect to the database, even if the
database comes up a later time.
It is recommended that ClearPool and ClearAllPools not be called until
the application can create valid connections back to the database.
.NET developers can develop code that continuously checks whether or
not a valid database connection can be created and calls ClearPool or
ClearAllPools once this is true.
Also, may be this post will help you.
Update:
As pointed by #MPelletier, for oracle 12 the link is different.
Generally speaking, you should avoid trying to manipulate the connection pool for any ADO.NET provider (and also WCF channels - an aside). If you application needs to be resilient in the face of underlying data errors (e.g. timeouts, broken connections in pool, etc.) then you should implement the appropriate level of transaction to ensure data integrity and retry logic to re-execute the failed operation.