USING STRONGLY TYPED INTERFACES WITH JPUBLISHER in Font

Printer Code 3 of 9 in Font USING STRONGLY TYPED INTERFACES WITH JPUBLISHER

String selectStmt = "select value(a) from address_table a"+ " where line1 = for update nowait"; pstmt = connection.prepareStatement ( selectStmt ); pstmt.setString( 1, "145 Apt # 7" ); orset = (OracleResultSet) pstmt.executeQuery(); if ( orset.next() ) { myAddress = (MyAddressORAData) orset.getORAData(1, MyAddressORAData.getORADataFactory() ); myAddress.setStreet ( "Wonderful St" ); String updateStmt = "update address_table a" + " set value(a) = " + " where a.line1 = "; opstmt = (OraclePreparedStatement) connection.prepareStatement ( updateStmt ); opstmt.setORAData (1, myAddress ); opstmt.setString (2, "145 Apt # 7" ); int rows = opstmt.executeUpdate(); System.out.println ( "Updated " + rows + " rows " ); } connection.commit(); } finally { JDBCUtil.close( orset ); JDBCUtil.close( opstmt ); } } Deleting Objects There is nothing special about deleting an object. It is a simple relational statement, as illustrated in the following _demoDelete() method: private static void _demoDelete( Connection connection) throws SQLException, ClassNotFoundException { PreparedStatement pstmt = null; try { String deleteStmt = "delete address_table a" + " where a.line1 like "; pstmt = connection.prepareStatement ( deleteStmt ); pstmt.setString (1, "Mountain View" ); int rows = pstmt.executeUpdate(); System.out.println ( "Deleted " + rows + " row(s) " ); connection.commit(); }

finally { JDBCUtil.close( pstmt ); } } } Now that you know how to use the SQLData interface and the Oracle extension interfaces ORAData and ORADataFactory, let s compare the two approaches.

In this section, we ll highlight the differences between the SQLData and ORAData interfaces. Note that there may be times when you have to use ORAData for example, if you want to create a custom class for a nonstandard Oracle-specific type. In practice, there are no major advantages or disadvantages to using either approach. The main advantage of using the SQLData interface, at least in theory, is that it is a JDBC standard and makes your Java code more portable across databases. However, at the time of this writing, the implementation and use of objects in different databases varies so much that the majority of such code contains vendor-dependent code anyway. Using the ORAData and ORADataFactory interfaces, on the other hand, has the following advantages (none of which is really earth-shattering): The ORAData interface has more flexibility than the SQLData interface. It lets you provide a mapping between Java object types and any SQL type supported by the oracle.sql package. For example, you can use it if you want to create a custom class for a nonstandard Oracle-specific type such as oracle.sql.BFILE. The ORAData interface does not require a type map to map the object type to Java classes. According to the documentation, using the ORAData interface leads to better performance since ORAData works directly with the internal format the driver uses to hold Oracle objects. This means there is no conversion required to hold the data. The tests I conducted to verify this statement were not conclusive, as in some cases, I actually found SQLData to be faster. So my advice is that you should use this criterion for choosing between the two approaches in your application only after running appropriate benchmarks in the context of your application.

You may have noticed that regardless of whether you use SQLData or ORAData, the code generated by JPublisher suffers from what many would justifiably consider a serious drawback. The problem is that the custom classes (which are domain objects that is, objects that represent end-user business entities such as an Address, a Person, and so on) are tightly coupled with the persistence mechanism. For example, the getAddress() method in the generated domain class MyAddressAuto executes the method get_address() to retrieve the data from the database. Even if database independence is not a goal of your design, it is a good coding practice to separate out the persistence mechanism that you use to save and retrieve your domain objects from the domain objects themselves. This is a fairly involved topic in its own right, and it s beyond the scope of this book. Many well-documented frameworks (such as the Spring framework) are available, using which this objective can be achieved.

Summary

In this chapter, you learned what strongly typed interfaces are. You examined the JDBC standard interface, SQLData, and the Oracle extension interfaces, ORAData and ORADataFactory. You learned about the various options provided by JPublisher, a utility that generates custom classes mapping SQL objects to Java for you. You also learned, through examples, how to use JPublisher to generate custom classes that implement either SQLData or ORAData interfaces that allow you to retrieve and manipulate objects stored in the database. In the next chapter, we will examine how to use collections and references in a JDBC program.