WO2011134233A1

WO2011134233A1 - Method and device for monitoring database connection pool

Info

Publication number: WO2011134233A1
Application number: PCT/CN2010/077270
Authority: WO
Inventors: 王萍
Original assignee: 中兴通讯股份有限公司
Priority date: 2010-04-29
Filing date: 2010-09-25
Publication date: 2011-11-03
Also published as: CN101840352A; CN101840352B

Abstract

A method and a device for monitoring a database connection pool are disclosed. The method includes: obtaining a database connection through a database connection pool. An object instance of a JAVA Database Connectivity (JDBC) interface implementing class is created based on the database connection, the JDBC interface implementing class is used for executing SQL statements. According to the implementing SQL statement defined by the public parameters class inheriting from the JDBC interface implementing class, the arguments and the method to be used are traced. All the object instances created by the database connection and the tracing information of the SQL statements thereof are stored. During the process of using the database connection to execute a database operation, when exceptions occurred in the monitored connection pool, all the object instances created by the database connection is obtained, and for each object instances, the tracing information of the SQL statement of the object instance is obtained.

Description

Method and device for monitoring database connection pool

The present invention relates to the field of JAVA application technologies, and in particular, to a method and device for monitoring a database connection pool. Background technique

JAVA is a general term for the JAVA programming language and JAVA platform introduced by Sun Microsystems. JAVA programming language (referred to as JAVA language) is an object-oriented, distributed, robust and secure, structure-neutral, portable, multi-threaded dynamic language. The JAVA platform consists of a Java Virtual Machine (VM) and a Java Application Programming Interface (API). The JAVA API provides a standard interface independent of the operating system for JAVA applications. JAVA Data Base Connectivity (JDBC, JAVA Data Base Connectivity) is a JAVA API for executing structured query language (SQL, Structured Query Language) statements. The group consists of classes and interfaces written in the JAVA language. It can establish connections with the database, send SQL statements, and process execution results. SQL is a programming language for database queries that access data and query, update, and manage relational database systems.

Database access is one of its core technologies in JAVA-based applications, especially for enterprise users. In order to solve the problems of frequent system resource overhead, slow response, low system stability, and memory leaks when accessing the database frequently, the database connection pool technology is introduced in the application system. The basic idea of a database connection pool is to create a "buffer pool" for database connections. The database connection pool will create a certain number of database connections into the database connection pool during initialization. The number of database connections initially created is determined by the set minimum number of connections, and the maximum number of connections in the database connection pool is set to prevent the application system. An endless connection to the database. When you need to establish a database connection, you only need to take a database connection from the database connection pool, so that After the use is completed, the database connection can be put back into the database connection pool, which avoids the system resource overhead caused by frequent establishment and shutdown of the database connection, and enables efficient and secure reuse of each database connection.

In the prior art, the database connection pool caches the database connection, which can reduce the system resource overhead, but cannot monitor the database operations performed by each database connection. Once the service uses the database connection for a long time or performs an illegal database operation, the database connection is caused. An exception occurs in the pool. The database connection pool can only catch exceptions, but it cannot locate which SQL statement is executed by which business. In order to avoid the system resource overhead caused by a large number of logs, it is also impossible to record all the SQL statements executed by each service in the log, so that it is particularly difficult to locate the problem of abnormal conditions when running multiple services or executing many SQL statements. Summary of the invention

The invention provides a method and a device for monitoring a database connection pool, which are used for tracking SQL statements executed by a database connection, thereby providing a basis for accurately and quickly realizing the problem location of an abnormal situation in the database connection pool.

A method for monitoring a database connection pool, the method comprising:

Obtain a database connection from the database connection pool;

Creating an object instance of a JAVA database connection (JDBC) interface implementation class for executing a Structured Query Language (SQL) statement based on the obtained database connection, and implementing SQL according to the public parameter class defined by the JDBC interface implementation class The statement tracks the variables and methods that need to be used to save all the object instances created by the database connection and their SQL statement tracking information. During the execution of the database operation using the obtained database connection, the abnormality in the database connection pool is monitored. Obtaining all object instances created by the database connection; and

For each object instance, the SQL statement tracking information of the object instance is obtained. A monitoring device for a database connection pool, the device comprising:

An obtaining unit, configured to obtain a database connection from a database connection pool;

a creating unit, configured to create an object instance of a JAVA database connection JDBC interface implementation class for executing a structured query language SQL statement based on the obtained database connection, and implement the public parameter class definition inherited by the JDBC interface implementation class The SQL statement keeps track of the variables and methods that need to be used, and saves all object instances created by the database connection and their SQL statement tracking information;

a monitoring unit, configured to acquire all object instances created by the database connection when an abnormality occurs in the database connection pool is monitored during the execution of the database operation by using the obtained database connection;

And an obtaining unit, configured to obtain, for each object instance, the SQL statement tracking information of the object instance.

The method and device for monitoring database connection pool provided by the invention, real-time caches the related SQL statement tracking information in the process of performing database operations in each database connection, and obtains the above-mentioned SQL statement tracking information when an abnormal situation occurs in the database connection pool, thereby realizing The tracking of the SQL statements executed by the database connection provides a basis for accurately and quickly realizing the problem location of the abnormal situation in the database connection execution database operation, and improves the stability of the database connection pool.

Other features and advantages of the invention will be set forth in the description which follows, The objectives and other advantages of the invention will be realized and attained by the <RTI DRAWINGS

1 is a schematic diagram of an internal class relationship of an improved database connection pool in an embodiment of the present invention; FIG. 2 is a schematic structural diagram of each key inner class of a database connection pool in an embodiment of the present invention; 3 is a flowchart of a method for creating a database connection according to an embodiment of the present invention;

4 is a flowchart of a method for monitoring a database connection pool according to an embodiment of the present invention;

FIG. 5 is a schematic diagram of a method for creating an instance of a PoolPreparedStatement object according to an embodiment of the present invention; FIG. 6 is a block diagram of a monitoring device for a database connection pool according to an embodiment of the present invention. detailed description

The embodiment of the invention provides a method and a device for monitoring a database connection pool in a JAVA application, which is used for tracking the SQL statement executed by the database connection, so as to accurately and quickly locate the database connection pool in the JAVA application process. The basis for anomalies that arise.

The preferred embodiments of the present invention are described with reference to the accompanying drawings, and the preferred embodiments described herein are intended to illustrate and explain the invention.

The inventors have found that in order to implement the tracking of the SQL statements executed by the database connection, thereby providing a basis for accurately and quickly realizing the problem location of the abnormal situation in the database resource pool, and improving the stability of the database connection pool, the database connection pool needs to be performed. Improved, real-time cache of SQL statement tracking information in the process of performing database operations in each database connection, such as SQL statements executed by database connections in the database connection pool and execution time thereof, so that the abnormality can be accurately and quickly located in the event of an abnormal situation The exception caused by which SQL statement executed by which business.

In a JAVA-based application system, JDBC is a JAVA API for executing SQL statements. JDBC consists of a set of classes and interfaces written in the Java language. In the embodiment of the present invention, the JDBC technology is also used to access the database, and the SQL statement executed by the database connection is tracked based on the interface provided by the JDBC.

See Figure 1 for the improved internal relationship of the database connection pool (in the JDBC standard database interface class referred to as JDBC interface class in Figure 1), the internal classes in the improved database connection pool and their mutuals are described below with reference to Figure 1 of the specification. The relationship is explained, where: [1] StatementUtil: Public parameter class, used to define the variables and methods needed to implement SQL statement tracking, including the Connection object instance of the JDBC standard database interface class Statement, ie the database connection, the Statement object instance, the Statement object instance to start the database operation That is, the time of the SQL statement, etc., the public parameter class StatementUtil is the base class of other internal Statement implementation classes in the improved database connection pool.

[2] PoolStatement: The database connection pool internally implements the Statement class, inherits the public parameter class StatementUtil , and implements the JDBC standard database interface class Statement , that is, the PoolStatement is the JDBC standard database interface class Statement corresponding to the JDBC interface implementation class.

[3] PoolPreparedStatement: The database connection pool internally implements the PreparedStatement class, inherits the JDBC interface implementation class PoolStatement, and implements the JDBC standard database interface class PreparedStatement (the JDBC standard database interface class PreparedStatement inherits the JDBC standard database interface class Statement), that is, the PoolPreparedStatement is the JDBC standard database. The JDBC interface implementation class corresponding to the interface class PreparedStatement.

[4] PoolCallableStatement: The database connection pool internally implements the CallableStatement class, inherits the JDBC interface implementation class PoolPreparedStatement, and implements the JDBC standard database interface class CallableStatement (the JDBC standard database interface class CallableStatement inherits the JDBC standard database interface class PreparedStatement), that is, the PoolCallableStatement is the JDBC standard database. The JDBC interface implementation class corresponding to the interface class CallableStatement.

[5] PoolConnection: Database connection pool internal definition Connection interface class, definition Get the database connection related information, such as the method of obtaining the database connection pool where the database connection is located, and obtain the database connection creation time.

[6] PoolConnectionlmpl: Database connection pool internal Connection implementation class, implement JDBC standard database interface class Connection and database connection pool internal definition Connection interface class PoolConnection, database connection pool cache a certain number The PoolConnectionImpl object instance, that is, PoolConnectionImpl is the JDBC interface implementation class corresponding to the JDBC standard database interface class Connection.

[7] getConection(): The basic method in the database connection pool. By calling this method, the database connection can be obtained. In the improved database connection pool, the method returns the PoolConnectionImpl object instance. Since PoolConnectionImpl implements the JDBC standard database interface, Therefore, the method of the Connection object instance is still used for the business.

[8] createStatement (): JDBC standard database interface class Connection defined method, by calling this method can get the Statement object instance, and then through a series of execution methods to achieve database operations.

[9] prepareStatementQ: JDBC standard database interface class Connection defined method, by calling this method can get the PreparedStatement object instance, and then through a series of implementation methods to achieve database operations.

[10] prepareCall (): JDBC standard database interface class Connection defined method, by calling this method can get the CallableStatement object instance, and then through a series of execution methods to achieve database operations.

The structure diagram of each key inner class in the improved database connection pool is shown in Figure 2. The key elements of several key inner classes in the improved database connection pool are described below.

Prior to this, several key elements of the connection pool implementation class ConnectionPoolImpl in the prior art are described:

1) The variable managed: ArrayList type is used to cache a database connection in the database connection pool, that is, a Connection object instance. Correspondingly, in the embodiment of the present invention, a certain number of PoolConnectionImpl object instances are cached.

2) newPooledConnection(): This method is used to create a database connection, returning a PoolConnectionImpl object instance (equivalent to the Connection object instance in the normal connection pool;), the database connection pool will create the database connection into the variable managed cache. 3) getConection() : This method is used to get the database connection for business use, and returns the PoolConnectionImpl object instance (equivalent to the Connection object instance in the normal connection pool).

Based on the existing database connection pool implementation class ConnectionPoolImpl, the key elements of the internal Connection implementation class PoolConnectionImpl in the improved database connection pool are described:

1) Variable conn: Connection object instance, used to complete various database operations.

2) Variable pool: ConnectionPoolImpl object instance, used to save the database connection pool object to which the database connection belongs.

3) statementSet: Set object instance, used to save the instance of the Statement object created by the database connection, is also an object instance of the StatementUtil subclass, in order to obtain the SQL statement of the database connection execution and SQL statement tracking information such as execution time.

4) Variable createTime: The creation time of the database connection.

5) Variable lastCheckinTime: The time the database connection was released after it was last used. 6) Variable lastCheckoutTime: The time when the database connection was last acquired. It can be combined with lastCheckinTime to determine the usage time of the database connection and whether the usage is released.

7) addStatement(Statement): Adds an instance of the Statement object to the statementSet collection variable. This method is called when the database connection creates a Statement object instance.

8) remove AllStatements(): Clears all Statement object instances in the statementSet, which is called when the database connection is released.

9) poolStatement(Statement): used to create a PoolStatement object instance,

The Statement object instance is taken as an input parameter and stored in the PoolStatement object instance. This method returns the created PoolStatement object instance.

10) poolPreparedStatement(PreparedStatement) : used to create The PoolPreparedStatement object instance, the PreparedStatement object instance is taken as an input parameter, and saved in the PoolPreparedStatement object instance, which returns the created PoolPreparedStatement object instance.

11) poolCallableStatement(CallableStatement): Used to create a PoolCallableStatement object instance. The CallableStatement object instance is used as an input parameter and saved in the PoolCallableStatement object instance. This method returns the created PoolCallableStatement object instance.

12) createStatementO: Implements a method in the Connection interface, which is used to create a Statement object instance, and uses it as the input parameter poolStatementQ to create a PoolStatement object instance. At the same time, the method addStatement() is called, and finally the created PoolStatement object instance is returned.

13) prepareStatementO: Implements the method in the Connection interface, which is used to create a PreparedStatement object instance, and uses it as the input method poolPreparedStatement() to create a PoolPreparedStatement object instance, and also calls the method addStatement() , which finally returns the created PoolPreparedStatement object instance.

14) prepareCall(): Implements a method in the Connection interface, which is used to create a CallableStatement object instance, and uses it as the inbound call method poolCallableStatement() to create a PoolCallableStatement object instance. At the same time, the method addStatement() is called, and finally the created PoolCallableStatement object is returned. Example.

Finally, the key elements of the public parameter class StatementUtil in the improved database connection pool are described:

1) The variable pooledConnection : the instance of the PoolConnectionlmpl object to which the instance object belongs.

2) Variable statement: An instance of the Statement object associated with this object instance.

3) Variable startExecTime: The time when the Statement object instance starts executing database operations. 4) Variable putedParameters: List type, used to save the parameters of the Statement object instance.

5) Variable executeFlag: Execution flag, where executeFlag takes a value of 0 to indicate unexecuted, executeFlag takes a value of 1 to execute commonSql, executeFlag has a value of 2 indicates that preparedSql is executed, and executeFlag has a value of 3 to execute batchSql.

6) batchSql: List type, used to save the SQL statement when executeBatch.

7) preparedSql: used to save the SQL statement executed by the PreparedStatement object instance.

8) commonSql: used to save the SQL statement executed by the Statement object instance.

9) StatementUtilO: The constructor of the StatementUtil object instance, which is a poolConnectionlmpl object instance and a Statement object instance, used to initialize the variable pooledConnection and the more statements

10) addParameter(): Add the incoming parameters to the variable putedParameters. 11) setExecuteFlag(): Sets the executeFlag flag to distinguish which SQL statement is currently executing.

12) appandBatchSQL(): Add the SQL statement to batchSql and use this method when executeFlag is 3.

13) setPreparedSql(): Set the preparedSql, use this method when executeFlag is 2. 14) setCommonSql(): Set commonSql, use this method when executeFlag is 1.

15) isExecTimeout(): Determines whether the execution timed out and the input time is the timeout period.

16) executeOver(): This method is called after the execution ends, clearing the executeFlag execution flag (set to 0, which means it is not executed) and startExecTime.

In the following, the implementation principle of the improved database connection pool is elaborated, which mainly includes three aspects:

(1) Implementation of JDBC standard database interface class The JDBC standard database interface class includes Connection, Statement . PreparedStatement . CallableStatement , where Connection defines the database connection, Statement, PreparedStatement, and CallableStatement define the variables and methods used to execute the SQL statement. Through the improvement of the database connection pool, the JDBC standard database interface classes Connection, Statement, PreparedStatement, and CallableStatement correspond to the JDBC interface implementation classes PoolConnectionlmpl, PoolStatement, PoolPreparedStatement, and PoolCallableStatement respectively, that is, Connection and PoolConnectionlmpl correspond to Statement and PoolStatement, PreparedStatement and PoolPreparedStatement Correspondingly, CallableStatement corresponds to PoolCallableStatement.

The above JDBC interface implementation class can be used as a JDBC standard database interface class, and can also add personalized variables and methods, that is, the database connection pool caches the JDBC standard database interface class Connection corresponding to the JDBC interface implementation class PoolConnectionlmpl Object instance, the actual return of the PoolConnectionlmpl object instance when the business obtains the database connection. The above improvements are transparent to the business, and the business uses the database connection as usual according to the JDBC standard database interface. Similarly, when the business obtains the Statement, PreparedStatement, and CallableStatement object instances by calling the methods created by the JDBC standard database interface class Connection, createStatement(), prepare Statement(), and prepareCall(), the JDBC standard database interface class actually returned by the PoolConnectionlmpl object instance corresponds. The object instance of the JDBC interface implementation class, that is, the PoolStatement, PoolPreparedStatement, and PoolCallableStatement object instances, the above improvements are also transparent to the business, and the business performs database operations according to the JDBC standard database interface as usual.

(2) Extension of the JDBC standard database interface class

The extension to the JDBC standard database interface class is reflected in two aspects: properties and inheritance. Adding attributes, that is, adding variables to the above JDBC interface implementation class, for saving phases The object instance and its related information, such as the JDBC interface implementation class PoolConnectionlmpl added variable conn (used to save the Connection object instance), pool (used to save the ConnectionPoolImpl object instance), etc., JDBC interface implementation class PoolPreparedStatement in the booster port The variable preparedStatement (used to save the PreparedStatement object instance), the JDBC interface implementation class PoolCallableStatement added a variable callableStatement (used to save the CallableStatement object instance). Add inheritance, that is, the JDBC interface implementation class PoolStatement, PoolPreparedStatement, PoolCallableStatement implements the JDBC standard database interface class Statement, PreparedStatement, CallableStatement, and the public parameter class StatementUtil, the public parameter class StatementUtil defines the variables and methods needed to implement SQL statement tracking. Including the JDBC standard database interface class Statement belongs to the Connection object instance that is the database connection, the Statement object instance, the Statement object instance to start the database operation time, etc., the internal Statement implementation class can be achieved by inheriting the public parameter class StatementUtil to achieve SQL statement tracking Variables and methods.

(3) Implementation of the method defined by the JDBC standard database interface class

Each JDBC interface implementation class calls the method defined by the JDBC standard database interface class when implementing the JDBC standard database interface. At the same time, in order to implement the specific processing of the SQL statement tracking, the database operation is finally implemented through the JDBC standard database interface, but the additional operation is added. For the processing of SQL statements, such as the JDBC interface implementation class PoolConnectionlmpl method prepareStatement () execution flow is: first call conn.prepareStatement (sql), then return the PreparedStatement object instance and itself as a parameter to create a PoolPreparedStatement object instance , then save the SQL statement, and finally return the created PoolPreparedStatement object instance. The implementation of other methods is similar to the implementation of the above method, and details are not described herein.

The database connection pool provided by the embodiment of the present invention is based on the improved database connection pool. The monitoring method is described in detail.

The embodiment of the present invention first provides a method for creating a database connection in a database connection pool. The implementation flowchart is as shown in FIG. 3, and includes the following steps:

S301. Initialize the variable managed, and the variable managed is used to cache the database connection. S302. Call the method newPooledConnectionO to create a Connection object instance, that is, the database connection conn.

S303. The database connection conn and the database connection pool object are used as input functions of the poolConnectionlmpl to create a PoolConnectionlmpl object instance, that is, the database connection pConiio

S304. Add the created database connection pConn to the variable managed cache.

S305. Determine whether the created database connection pConn reaches the preset maximum number of connections. If yes, the process ends. If no, the process returns to step S302.

The embodiment of the invention provides a method for monitoring a database connection pool. As shown in FIG. 4, the method includes the following steps:

S401. Obtain a PoolConnectionlmpl object instance from a database connection pool, that is, a database connection pconn„

In the specific implementation, the method Connection getConection() is used to obtain the PoolConnectionlmpl object instance, ie the database connection pconn, the method getConection() returns the PoolConnectionlmpl object instance, and the database connection conn is a variable in the database connection pconn.

S402. Based on the obtained database connection, pconn creates an object instance of a JDBC interface implementation class for executing the SQL statement.

In a specific implementation, the JDBC interface implementation class for executing the SQL statement includes a PoolStatement, a PoolPreparedStatement, and a PoolCallableStatement, and the corresponding object instance includes a PoolStatement object instance, a PoolPreparedStatement object instance, and a PoolCallableStatement object instance; and the database connection pconn is used to execute the SQL. The object instance of the JDBC interface implementation class of the statement can be one of a PoolStatement object instance, a PoolPreparedStatement object instance, a PoolCallableStatement object instance, or any combination.

In the embodiment of the present invention, an implementation process of creating a PoolPreparedStatement object instance ppstat is taken as an example. For details, refer to FIG. 5. The implementation process of creating a PoolStatement object instance and a PoolCallableStatement object instance is similar to the implementation process of creating a PoolPreparedStatement object instance, and is no longer Narration.

S403. Implementing a public parameter inherited by the JDBC interface implementation class for executing the SQL statement. Implementing the SQL statement to track the variables and methods to be used, and saving all object instances created by the database connection pconn and their SQL statement tracking information.

For example, it is assumed that the object instance of the JDBC interface implementation class created by the obtained database connection pconn in S402 is the PoolPreparedStatement object instance ppstat, and in the implementation of S402, the method of calling the PoolPreparedStatement object instance ppstat setPreparedSql() , save the SQL statement executed by the PreparedStatement object instance; add the PoolPreparedStatement object instance ppstat to the statementSet collection variable by calling the method addStatement().

5404. In the process of performing a database operation using the obtained database connection pconn, when an abnormality occurs in the database connection pool is monitored, all object instances created by the database connection are obtained.

In the specific implementation, when the database connection pool monitoring task monitors an abnormal situation in the database connection pool, the statementSet collection variable is obtained by calling the method getStatementSet(), and the statementSet collection variable stores all the object instances created by the database connection;

5405. Obtain, according to each object instance, the SQL statement tracking information of the object instance. In a specific implementation, for each object instance in the statementSet collection variable, the object instance is obtained by calling the getSQLString() and getExecTimeQ methods of each object instance. The SQL statement trace information, the SQL statement trace information includes the SQL statement executed by the database connection and the execution time and other information, wherein the methods getSQLString() and getExecTime() are defined by the public parameter class StatementUtil.

At this point, the monitoring of the database connection pool has been implemented. In the specific implementation, the method further includes the following steps:

When the database connection pconn is released, all the object instances created by the saved database connection are emptied, and the database connection is released. pconn refers to putting the database connection pconn back into the database connection pool.

Further, in order to facilitate the user to locate the problem of the abnormal situation, the method may further include the following steps:

The obtained SQL statement tracking information of each object instance is printed in a log file for the user to locate the problem of the abnormal situation.

The method of creating a PoolPreparedStatement object instance, as shown in Figure 5, includes the following steps:

S501. Define a variable ppstat of the JDBC interface implementation class PoolPreparedStatement, and assign a value of null.

S502. Call the database connection conn defined method prepareStatement() to create a PreparedStatement object instance pstat.

S503. Connect the database connection pconn and the PreparedStatement object instance pstat as a constructor of the PoolPreparedStatement to create a PoolPreparedStatement object instance ppstat.

Based on the same technical concept, an embodiment of the present invention provides a monitoring device for a database connection pool. As shown in FIG. 6, the device includes:

The obtaining unit 601 is configured to obtain a database connection from the database connection pool.

a creating unit 602, configured to create a SQL statement based on the obtained database connection The JDBC interface implements the object instance of the class, and according to the public parameter class defined by the JDBC interface implementation class, implements the SQL statement to track the variables and methods to be used, saves all the object instances created by the database connection and its SQL statement tracking. information.

The monitoring unit 603 is configured to: when an abnormality occurs in the database connection pool is monitored during the database operation performed by using the obtained database connection, obtain all object instances created by the database connection.

The obtaining unit 604 is configured to obtain SQL statement tracking information of the object instance for each object instance.

In a specific implementation, the monitoring device of the database connection pool may further include:

The clear unit 605 is used to clear all the object instances created by the saved database connection when the database connection is released.

In a specific implementation, in order to facilitate the user to locate the problem of the abnormal situation, the monitoring device of the database connection pool may further include:

The printing unit 606 is configured to print the obtained SQL statement tracking information of each object instance in a log file, so that the user can locate the problem of the abnormal situation.

The method and device for monitoring the database connection pool provided by the embodiment of the present invention, real-time cache the related SQL statement tracking information in the process of performing database operations in each database connection, and obtain the above-mentioned SQL statement tracking information when an abnormality occurs in the database connection pool, thereby The tracking of the SQL statements executed by the database connection is realized, which provides a basis for accurately and quickly realizing the problem location of the abnormal situation in the process of performing database operations in the database connection, and improves the stability of the database connection pool.

Those skilled in the art will appreciate that embodiments of the present invention can be provided as a method, apparatus, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment, or a combination of software and hardware. Moreover, the invention can be embodied in the form of one or more computer program products embodied on a computer-usable storage medium (including but not limited to disk storage, CD-ROM, optical storage, etc.) in which computer usable program code is embodied. The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus, and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flowchart illustrations and/or FIG. These computer program instructions can be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing device to produce a machine for the execution of instructions for execution by a processor of a computer or other programmable data processing device. Means for implementing the functions specified in one or more of the flow or in a block or blocks of the flow chart.

The computer program instructions can also be stored in a computer readable memory that can direct a computer or other programmable data processing device to operate in a particular manner, such that the instructions stored in the computer readable memory produce an article of manufacture comprising the instruction device. The apparatus implements the functions specified in one or more blocks of a flow or a flow and/or block diagram of the flowchart.

These computer program instructions can also be loaded onto a computer or other programmable data processing device such that a series of operational steps are performed on a computer or other programmable device to produce computer-implemented processing for execution on a computer or other programmable device. The instructions provide steps for implementing the functions specified in one or more of the flow or in a block or blocks of a flow diagram. The spirit and scope of the invention. Thus, it is intended that the present invention cover the modifications and modifications of the invention

Claims

Claim

A method for monitoring a database connection pool, the method comprising: obtaining a database connection from a database connection pool;

Creating an object instance of a JAVA database connection (JDBC) interface implementation class for executing a Structured Query Language (SQL) statement based on the obtained database connection, and implementing SQL according to the public parameter class defined by the JDBC interface implementation class The statement tracks the variables and methods that need to be used to save all the object instances created by the database connection and their SQL statement tracking information. During the execution of the database operation using the obtained database connection, the abnormality in the database connection pool is monitored. Obtaining all object instances created by the database connection; obtaining, for each object instance, SQL statement tracking information of the object instance.

2. The method according to claim 1, wherein the method further comprises: when the database connection is released, clearing all saved object instances created by the database connection.

3. The method according to claim 1, wherein the SQL statement tracking information of the object instance comprises an SQL statement executed by the object instance and an execution time.

The method according to claim 1, 2 or 3, wherein the method further comprises: printing the obtained SQL statement tracking information of each object instance in a log file for the user to locate the problem of the abnormal situation.

The method according to claim 1, 2 or 3, wherein the JDBC interface implementation class for executing the SQL statement comprises: implementing a JDBC standard database interface class Statement JDBC interface implementation class PoolStatement, implementing a JDBC standard The JDBC interface implementation class PoolPreparedStatement of the database interface class PreparedStatement, and the JDBC interface implementation class PoolCallableStatement that implements the JDBC standard database interface class CallableStatement.

6. The method of claim 5, wherein: creating the PoolPreparedStatement object instances include:

Create a PreparedStatement object instance;

Create a PoolPreparedStatement object instance by using the obtained database connection and the PreparedStatement object instance as the constructor of the PoolPreparedStatement.

The method according to claim 1, 2 or 3, wherein the database connection is a PoolConnectionlmpl object instance, and the PoolConnectionlmpl is a JDBC interface implementation class for implementing a JDBC standard database interface class Connection, in the database connection pool. Creating the database connection includes:

Initialize variables in the database connection pool that are used to cache database connections;

Create a Connection object instance, call the Connection object instance and the database connection pool object as the constructor of the PoolConnectionlmpl input parameter, create a database connection, and add the created database connection to the variable cache;

The creation of a database connection is stopped when the number of database connections created reaches the preset maximum number of connections.

A monitoring device for a database connection pool, the device comprising: an obtaining unit, configured to acquire a database connection from a database connection pool;

An obtaining unit, configured to obtain an SQL statement of the object instance for each object instance tracking information.

The device according to claim 8, wherein the device further comprises: an emptying unit, configured to clear all the object instances created by the saved database connection when the database connection is released.

The device according to claim 8 or 9, wherein the device further comprises: a printing unit, configured to print the obtained SQL statement tracking information of each object instance in a file for the user to perform an abnormal situation. Problem positioning.