Important NOTE: this part of the article is the owner of the collection from the Internet, and if you think that the content of the document violates your rights, please contact the collation (excelarthur@yahoo.com.cn), and Dev2dev site has nothing to do.
Characteristics of JDBC3.0
1. Database connection pool framework in JDBC3.0 specification
The JDBC3.0 specification provides a framework for supporting the database connection pool, which only specifies how to support the implementation of the connection pool, while the implementation of the JDBC 3.0 specification for the connection pool does not provide relevant provisions. This framework enables developers of different roles to work together to implement database connection pooling.
Through the JDBC3.0 specification can know that the implementation of specific database connection pool can be divided into JDBC driver level and application server level. Any relevant work in the JDBC driver-level implementation is specifically implemented by the JDBC Drvier developer of a particular database vendor, that is, JDBC driver needs to provide support for the database connection pool, as well as a specific implementation of the database connection pool. In the implementation of the database connection pool at the application server level, the JDBC driver developer and application Server developer of a particular database manufacturer together implement the database connection pool (but now most application The mechanisms and specifications for connection pooling implemented by the server manufacturer refer to differences in that the JDBC driver for a particular database vendor provides support for the database connection pool and specific application server vendors provide a concrete implementation of the database connection pool.
The JDBC3.0 specification provides the following classes and interfaces to support the implementation of the database connection pool.
Javax.sql.ConnectionEvent javax.sql.ConnectionPoolDataSource javax.sql.PooledConnection Javax.sql.ConnectionEventListener
In addition to Javax.sql.ConnectionEvent is the class, the other is the interface.
Diagram of the JDBC3.0 connection pool framework
This diagram allows you to approximate the location of the relevant interfaces in a typical three-tier environment.
2, the search automatically generated keywords
To address the need to get the value of automatically generated or automatically added keywords, the JDBC 3.0 API now makes it easy to get this value. To determine the value of any resulting keyword, simply specify an optional tag in the Execute () method of the statement to indicate that you are interested in getting the resulting value. The extent of your interest can be statement.return_generated_keys, or it can be statement.no_generated_keys. After executing this statement, the resulting keyword value is obtained by retrieving the ResultSet from the Statement instance method Getgeneratedkeys (), ResultSet contains the columns of each generated keyword, The following example creates a new author and returns the corresponding automatically generated keyword.
..... Statement stmt = Conn.createstatement ();
Obtain the generated key that results from the query.
Stmt.executeupdate ("INSERT into authors" +
"(first_name, last_name)" +
"VALUES (' Ghq ', ' WXL ')",
Statement.return_generated_keys);
ResultSet rs = Stmt.getgeneratedkeys ();
if (Rs.next ()) {
//Retrieve the auto generated key (s).
int key = Rs.getint ();
}
......
3. Return multiple results
One limitation of the JDBC 2 specification is that at any given time, statements that return multiple results can only open one resultset. As part of the change in the JDBC 3.0 specification, the specification will allow the Statement interface to support multiple open resultsets. However, it is important that the execute () method still closes any ResultSet that was opened in the previous execute () call. Therefore, to support multiple open results, the Statement interface will be preceded by an overloaded Getmoreresults () method. The new method makes an integer tag that specifies the behavior of the previous open ResultSet when the Getresultset () method is invoked. The interface defines the markup as follows:
Close_all_results: When Getmoreresults () is invoked, all previously opened ResultSet objects will be closed.
Close_current_result: When Getmoreresults () is invoked, the current ResultSet object will be closed.
Keep_current_result: When Getmoreresults () is invoked, the current ResultSet object will not be closed.
Here is an example of how to handle multiple open results.
..... String Proccall;
Set the value of Proccall to call a stored procedure.
... CallableStatement cstmt = Connection.preparecall (proccall);
int retval = Cstmt.execute ();
if (retval = = False) {
//The statement returned a update count, so handle it.
..
} else {//ResultSet
ResultSet rs1 = Cstmt.getresultset ();
... retval = Cstmt.getmoreresults (statement.keep_current_result);
if (retval = = True) {
ResultSet rs2 = Cstmt.getresultset ();
Both resultsets are open and ready for use.
Rs2.next ();
Rs1.next ();
..
}}
......
4, the use of savepoint in the transaction
Perhaps the most exciting additional feature of JDBC 3.0 is savepoint. Transaction support in JDBC 2 allows developers to control concurrent access to data, ensuring that persistent data is always in a consistent state. Unfortunately, it is sometimes necessary to have a little more control over the transaction, rather than simply rolling back every change in the current transaction. Under JDBC 3.0, this control can be obtained through savepoint. The SavePoint interface allows you to split a transaction into logical breakpoints to control how many transactions need to be rolled back. The following figure shows how to apply SavePoint in a transaction.
A visual representation of SavePoint
You may not often need to use savepoint. However, in a general situation savepoint will work, that is, you need to make a series of changes, but before you know all the results are not sure which part of these changes should be retained. The following code example shows how to use the SavePoint interface.
......
Conn.setautocommit (false);
Set a conservative transaction isolation level.
Conn.settransactionisolation (connection.transaction_serializable);
Statement stmt = Conn.createstatement ();
int rows = Stmt.executeupdate ("INSERT into authors" +
"(first_name, last_name) VALUES" +
"(' Ghq ', ' WXL ')");
//Set a named savepoint.
SavePoint svpt = Conn.setsavepoint ("Newauthor");
... rows = stmt.executeupdate ("UPDATE authors set type = ' Fiction '" +
"WHERE last_name = ' WXL '");
... Conn.rollback (SVPT);
... The author has been added, but not updated.
Conn.commit ();
......
5. Other characteristics
1) Meta Data API
The metadata API has been updated, and the DatabaseMetaData interface can now retrieve the SQL type hierarchy, and a new Parametermetadata interface can describe the types and attributes of the parameters in the PreparedStatement object.
2 named parameters in Callablestatements
Before JDBC 3.0, set a parameter in a stored procedure to specify its index value, not its name. The CallableStatement interface has been updated and you can now specify the parameters by name.
3 Changes in data types
The data types supported by JDBC have made several changes, one of which is the addition of two new data types.
To facilitate the modification of values for CLOB (Character Large object, character giant object), BLOB (Binary Large object, binary Macro object) and REF (SQL structure) type, the data type interface with the same name is updated. Next, because we are now able to update the values of these data types, the ResultSet interface has also been modified to support updates to the columns of these data types, as well as to the array type. The two new data types that are added are Java.sql.Types.DATALINK and Java.sql.Types.BOOLEAN. The new data type refers to the SQL type with the same name. DATALINK provides access to or URLs to external resources, and BOOLEAN types are logically equivalent to BIT types, but add semantic meaning. The DATALINK column value is retrieved from an instance of ResultSet by using the new GetURL () method, and the BOOLEAN type is retrieved by using Getboolean ().
Binary Large Object blob
A Blob object is a Java-language mapping of an SQL BLOB. A SQL blob is a built-in type that can store a binary large object in a database. The methods in interfaces resultset, CallableStatement, and PreparedStatement allow programmers to access SQL 99 type blobs in the same way that access SQL 92 built-in types.
In the standard implementation, the JDBC driver uses the SQL Type Locator (BLOB) in the background to implement the Blob interface. LOCATOR (BLOBs) point to the SQL BLOB values that are stored on the database server, and these actions work on the LOCATOR (locator) with the same result as the function in the BLOB value itself. This means that users can perform operations on a single BLOB instance without having to materialize the BLOB data to the user, which significantly improves performance. Because the driver uses locator (BLOB) in the background, its use is completely transparent to the programmer.
The standard behavior of a BLOB instance remains in effect until the transaction (the transaction that creates a blob) performs a commit or rollback operation.
Statement stmt = con. Createstatement (resultset.type_insensitive,
resultset.concur_read_only);
ResultSet rs = stmt.excutequery ("Select DATA from TABLE 1");
If (Rs.next ()) {
rs.first ();
Blob Blob=rs.getblob ("DATA");
}
A variable blob contains a logical pointer to a BLOB value that is saved in the data column in the first row of the result set Rs. Even if a variable blob does not actually contain a value in a BLOB value, the application performs operations on the BLOB as if it were on the actual data. That is, any action that an application does on a BLOB will affect the BLOB value in the table. Java.io.InputStream in = Blob.getbinarystream ();
BYTE B; while ((b = in.read ()) >-1) {System.out.println (b);} The next code also materialized that the BLOB pointed at the blobs was worth all the data, but it produced a byte array instead of an input stream. Long len = Blob.length ();
byte [] data = Blob.getbytes (1,len);
for (int i=0;i<len;i++) {byte b = data[i];
System.out.println (b); The variable data copies all the bytes of the BLOB value that the blob points to. This is because the parameter value passed to the method GetBytes illustrates the entire BLOB value: The first parameter indicates that the byte is returned from the first byte, and the second argument indicates that the length of the byte it returns is the length of the BLOB value. PreparedStatement method of Setblob. The following code implements this function:
Blob stats = Rs.getblob ("stats");
PreparedStatement pstmt= con.preparedstatement (
"UPDATE sightings SET meas=?") WHERE area = ' BEIJING ');
Pstmt.setblob (1,stats);
Pstmt.excuteupdate ();
byte [] bytes = Blob2.getbytes (1,blob2.length ()); Blob.setbytes (1,bytes,0,512);The following code snippet shows how to add only a specific part of a byte array to a BLOB object. In this case, the method SetBytes accepts two additional parameters to indicate which part of the byte array needs to be increased. One of the parameters indicates the starting offset of the byte array, and the other indicates how many contiguous bytes the byte array contains.
byte [] bytes={...};
Blob.setbytes (1,bytes,0,512); in addition to adding bytes to a Blob object, the Blob interface provides a way to delete bytes. Method truncate takes a byte number as a parameter and shortens the Blob object based on that number. byte [] Val ={0,1,2,3,4};
Blob Data =rs.getblob ("data");
int numwritten = data.setbytes (1,val);
if (dbmd.locatorupdatecopy () = = True) {
preparedstatement pstmt= con. PreparedStatement (
"UPDATE statistics SET DATA =? WHERE REGION = ' BEIJING ');
Pstmt.setblob ("Data", data);
Pstmt.executeupdate ();
}
Character large Object Clob
Meta-Data interface use detailed
The three meta data Interface DatabaseMetaData, ResultSetMetaData, and Parametermetadata interfaces are three commonly used metadata interfaces. DatabaseMetaData provides information related to a database or DBMS; ResultSetMetaData objects provide information related to a column in a particular resultset instance The Parametermetadata object provides information about the parameters of the PreparedStatement object. The content discussed in this article is not limited to one version of JDBC, but is based on the 1.0-3.0 specification.
Statement stmt= con. Createstatement ();
ResultSet rs = stmt.executequery ("SELECT * from Sales");
ResultSetMetaData RSMD = Rs.getmetadata ();
resultset rs = stmt.exec
Utequery ("SELECT * from Sales");
ResultSetMetaData RSMD = Rs.getmetadata ();
int numberofcolumns = Rsmd.getcolumncount ();
while (Rs.next ()) {for (int i=1;i<=numberofcolumn;i++) {String s = rs.getstring (i); System.out.println ("Column" +i + ":" +s + ");}} It is worth noting that the ResultSet method used to retrieve all the column values is getstring. This is a relatively easy method when you don't know the type of each column, and if you want to be able to retrieve all the data types (including the SQL 99 data type), you can use method GetObject, which is the only way to ensure that all columns are retrieved. Two methods are Getcolumntype and Getcolumntypename. The Getcolumntype method is used to determine the JDBC type of the value stored in the specified column. The method returns the JDBC type with an int value. The following code obtains the JDBC type for the second column of Rs:
ResultSetMetaData RSMD = Rs.getmetadata (); int jdbctype = Rsmd.getcolumntype (2);
isautoincrement iscurrency issigned getprecision getscale isnullable getcolumndisplaysize
Import java.sql.*; public class static primarykeysexample{public static void Main (string args[]) {string url = ' Jdbc:mySubprotocol:myDataSo
Urce ";
Connection con;
String createstring = "CREATE table SUPPLIERSPK" + "(sup_id integer NOT NULL," + "sup_name varchar (40)," +
"Street varchar", "+" city varchar (m) "+" state char (+), "+" zip char (10), "+
"PRIMARY KEY (SUP_ID)");
Statement stmt; try{class.forname ("Mydriver.classname");}
catch (Java.lang.ClassNotFoundException e) {System.err.println ("classnotfoundexception:");
System.err.println ("E.getmessage ()");
try{con =drivermanager.getconnection (URL, "username", "pwd");
Stmt=con.createstatement;
Stmt.executeupdate (createstring);
DatabaseMetaData Dbmd=con.getmetadata ();
ResultSet rs= Dbmd.getprimarykey (null,null, "SUPLIERSPK");
while (Rs.next ()) {String name =rs.getstring ("table_name");
String columnname=rs.getstring ("column_name"); String keyseq=rs.getstring ("Key_seq”);
String pkname=rs.getstring ("Pk_name");
SYSTEM.OUT.PRINTLN ("Table name:" +name);
SYSTEM.OUT.PRINTLN ("Column name:" +columnname);
SYSTEM.OUT.PRINTLN ("Sequence in key:" +keyseq);
SYSTEM.OUT.PRINTLN ("PRIMARY Key Name:" +pkname);}
Rs.close ();
Stmt.close ();
Con.close ();
}catch (SQLException ex) {System.err.println ("SQLException:" +ex.getmessage ());}}}If the primary key is redundant, then method Getprimarykeys will describe each column in detail. The value in the column KEY_SEQ represents which column is described.You can use the Parametermetadata object to get information about a PreparedStatement object or a CallableStatement object. These parameters are determined by the "?" placeholder denotes, "?" Placeholders are SQL statements that are provided to the connection method Preparestatement and Preparecall. The following line of code creates a PreparedStatement object using two parameter placeholders.
PreparedStatement pstmt=con.preparestatement ("SELECT ID from Employees where dept=?") and Salary>? ");
These parameters are numbered according to their ordinal number, so the first parameter is numbered 1, the second parameter is number 2, and so on. In the preceding line of code, parameter 1 is a value in column dept, and Parameter 2 is a value in salary. The following code snippet is used to find out how many parameters the PreparedStatement pstmt has. First create the pstmt and use it to create the Parametermetadata object PMD, which contains information about the parameters in pstmt. Then invoke the method getColumnCount on PMD to find out how many parameters the pstmt has.
PreparedStatement pstmt=con.preparestatement ( "UPDATE employees set salary =? Where level=? "); Parametermetadata PMD = Pstmt.getparametermetadata (); int Count=pmd.getparametercount ();The value of the variable count should be equal to 2. Method GetParameterCount does not accept arguments because it returns information about all parameters of the PreparedStatement object. All other methods in the Parametermetadata interface accept the ordinal number to represent the parameters of the information to be queried.
if (Boolean b =dbms.supportsresultsetholdability (ResultSet.
Hold_cursors_over_commit) {statement.stmt=con.createstatement (resultset.type_scroll_insensitive,
Resultset.concur_updatable, Resultset.hold_cursors_over_commit); refer to the JDBC API Reference maydene Fisher etc. "RowSet
The rowset object is a container of tabular data that encapsulates a set of data rows obtained from the data source. In the basic implementation of the rowset interface, the data rows are fetched from the JDBC data source. Because rowsets can be customized, data in a rowset can come from spreadsheets, flat files (flat files?). or any other table style data source. The rowset object is an extension of the ResultSet interface, which means that the rowset object is scrollable, updatable, and capable of performing any action that the ResultSet object can perform.
The rowset object differs from the ResultSet object, which is the JavaBean component, so the object has a JavaBean attribute and follows its event model. Also, the properties of the rowset object allow the object to establish its own database connection and execute its own query. In addition, rowset can be disconnected, which means that in the process of using a rowset, you do not have to keep open connections to the data source. In addition, the rowset can be serialized, so it can be sent over the network to the remote object.
In general, the JDBC API can be divided into two categories: the rowset section and the driver section. Rowset and interfaces that support it are implemented using other JDBC APIs. Logically, classes that implement the rowset interface can be viewed as software that executes on the upper level of the JDBC driver.
Now in J2SE 5.0, the JDBC API can be divided into three categories, with the exception of the two categories above, and the 5 standard implementations of the rowset interface. These implementations provide a set of interfaces to extend the basic rowset interface by establishing application on these interfaces to ensure that implementation of event handling, cursor control, and other operations follows the JDBC API.
The rowset interface provides a set of basic methods that are common to all rowsets. Because all rowset objects are JavaBean components, the rowset interface has methods for adding and removing event listener, as well as for get/set all properties of rowset objects. Most properties of the rowset object support establishing a connection or executing a command. To execute SQL statements such as queries, updates, and generate a result set from which data can be obtained, a rowset uses a connection to a data source.
If a component wants to be notified of events that occur on the rowset object, it should implement the Rowsetlistener interface and register with the rowset object. This is listener, a GUI component. So each time the rowset generates an event, listener gets a notification of the event, which keeps its cursor position and data consistent with the contents of the rowset.
The rowsetinternal, Rowsetreader, and Rowsetwriter interfaces support the Reader/weiter tool for rowsets. Reader is an instance of a class that implements the Rowsetreader interface to read data and insert data into a rowset. Writer is an instance of a class that implements the Rowsetwriter interface, which is used to write the modified data back to the data source. Reader and writer, like the listener, are dynamically registered with the rowset.
The rowset object that invokes reader or writer must be an instance of the class that implements the Rowsetinternal interface. This interface provides an additional method for reader or writer to manipulate the internal state of the rowset. For example, a rowset can track its initial value, and the Rowsetinternal method allows writer to detect whether the corresponding data in the data source has been modified by another user. In addition, you can use the Rowsetinternal method to get the input parameters set for the rowset's command string, as well as to get the connection passed to the rowset. Finally, the Rowsetinternal method allows reader to set a new Rowsetmetadata object that describes the row set that Reder will insert into the rowset.
The rowset can be connected, it can also be disconnected, a connected rowset object that maintains a connection to the data source throughout the use, and an disconnected rowset that connects to its data source only when reading data from the data source or writing data back to the data source. If the rowset is disconnected, it does not require a full implementation of the JDBC driver or JDBC API. This makes it very compact and thus becomes the ideal container for sending a set of data to a thin client. This client can choose to update the data and send the rowset back to the application server. On the server side, the disconnected rowset object uses its reader to establish a connection to the data source and writes the data back to the data source. The implementation of this operation depends on how the reader is implemented. Typically, reader delegates an operation that establishes the connection and reads/writes data to the JDBC driver.
Event model for Rowset
The rowset event model enables a Java object or component to receive notification of events generated by the rowset object. The establishment of the notification mechanism includes the notified component, as well as the rowset object itself. First, every component that wishes to receive an event notification must implement the Rowsetlistener interface. The rowset object must then register each component, which is done by adding the components to the event notification component list of the rowset object. In this case, such a component is a listener, an instance of a class that implements the Rowsetlistener method, and has been registered with the rowset object.
Three kinds of events can occur in a rowset object: Cursor movement, data row changes (INS, Del, UPD), or the entire contents of the object change. The cursormoved, RowChanged, and rowsetchanged methods of the Rowsetlistener interface correspond to these events respectively. When an event occurs, the rowset creates a Rowsetevent object that uses this object to identify the rowset as an event source. The appropriate Rowsetlistender method is invoked on each listener and a Rowsetevent object is passed as an input parameter to this method, and the event is notified to all listener of the rowset.
Rowset Property
The rowset interface provides a set of JavaBeans properties that you can configure to connect to a data source and get a collection of data rows. Rowset Some properties may not be required, depending on the specific implementation. If you establish a connection with a URL or a data source name, the other property is optional as long as one of the properties is set. If two properties are set, the most recently set property is used. If the data for a rowset is obtained from a non-SQL data source that is not a supported name command, such as a spreadsheet, you do not need to set command properties.
Explanation of several interfaces
Joinrowsetimpl jrs=new Joinrowsetimpl ();
ResultSet rs1 = Stmt.executequery ("SELECT * FROM Employees");
Cachedrowsetimpl empl=new Cachedrowsetimpl ();
Empl.populate (RS1);
Empl.setmatchcolumn (1);
Jrs.addrowset (EMPL);
ResultSet rs2=stmt.executequery ("SELECT * from Bonum_plan");
Cachedrowsetimpl bonums= new Cachedrowsetimpl ();
Bonus.populate (RS2);
Bonus.setmatchcolumn (1); Jrs.addrowset (bonus);//merged Xaconnection Introduction
The Xaconnection object is a Pooledconnection object that can be used for distributed transactions. It represents a physical connection to a database that can be used by a server in a multi-tier structure to create a connection object that is returned to the application. Because it is obtained by extending the Pooledconnection interface, it inherits all of its methods and adds its own method Getxaresource.
Commands in distributed transactions can be sent to multiple DBMS servers distributed transactions are managed with a middle-tier application server and external transaction managers and JDBC servers, and these three parts of the middle tier infrastructure provide plumbing.
The first element of a distributed transaction infrastructure is the transaction manager, which can be a JTA implementation. The transaction manager controls the transaction boundary and the two-phase commit process. It initiates and closes the components associated with the Distributed transaction Xaconnection object and tracks the DBMS servers that are involved in the distributed transaction. The transaction manager runs in each DBMS to decide whether to commit the transaction, and the transaction manager submits the transaction only if all the DBMS agrees to commit, otherwise it is rollback.
Another element of a distributed transaction is the JDBC driver that supports the JDBC API, and the driver must contain classes that implement the Xadatasource and Xaconnection interfaces. The Xadataresource interface is similar to the DataSource interface, but it creates objects that are xaconnection objects rather than connection objects. The Xaconnection object that inherits from Pooledconnection is special in that it can be used to get Xasource objects. The transaction manager uses this Xarource object to start and end the component associated with this xaconnection in a distributed transaction.
The third part of the distributed transaction infrastructure is usually a connection pooling module. The Xaconnection interface inherits from the Pooledconnection interface, which means that the database connection in a distributed transaction can come from a connection pool managed by a connection pool module.
| Td>dev2dev id:lhbing, Dev2dev forum Moderator, WEBLOIGC and Java technology enthusiast | |
Start building with 50+ products and up to 12 months usage for Elastic Compute Service
1 on 1 presale consultation
24/7 Technical Support 6 Free Tickets per Quarter Faster Response
Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.
A comprehensive suite of global cloud computing services to power your business
Payment Methods We Support
