10 JDBC Best pratices in Java
Here is my list of top 10 JDBC best practices in Java which helps to avoid potential error, to get better performance and helps to write robust Java database connection code.
JDBC Best Practice #1: Use PreparedStatement
This is by far most popular JDBC practices suggested by everyone who has worked in JDBC API in Java. Indeed PreparedStatement deserve that admiration because of useful services it provides like prevention from SQL injection, Precompiled SQL queries and use of bind variables as discussed in why Use PreparedStatement in Java .
JDBC Best Practice #2: Use ConnectionPool
ConnectionPool as JDBC best practice has already gained recognition and it even become standard now days. Several framework provides in built connection Pool facility like Database Connection Pool in Spring, DBCP and if you are running in managed environment like J2EE Application Server e.g. WAS or JBOSS, Server will provide Connection Pool facility. rational behind this JDBC best practices is that Creating JDBC connection take relatively longer time which can increase overall response time, by caching JDBC connection in pool application can immediately access database.
JDBC Best Practice #3: Disable auto commit mode
This is one of those JDBC best practices which provided substantial performance gain in our JDBC batch update example. Its recommended to run SQL query with auto commit mode disable. Rational behind this JDBC best practice is that with auto commit mode disabled you can group SQL Statement in one transaction while in case of auto commit mode every SQL statement runs in its own transaction and committed as soon as it finishes. So always run queries with auto commit mode disabled
JDBC Best Practice #4: Use JDBC Batch Update
This is another JDBC best practice which is very popular. JDBC API provides addBatch() method to add SQL queries into batch and executeBatch() to send batch queries for execution. Rational behind this JDBC best practices is that, JDBC batch update potentially reduce number of database roundtrip which result in significant performance gain. So always Use JDBC batch update for insertion and update queries.
JDBC Best Practice #5: Access ResultSet using column name to avoid invalidColumIndexError
JDBC API allows to access data returned by SELECT query using ResultSet, which can further be accessed using either column name or column index. This JDBC best practice suggest using column name over column index in order to avoid InvalidColumnIndexException which comes if index of column is incorrect, most common of them is 0, since ResultSet column Index starts from 1, zero is invalid. Also you don’t need to change your JDBC access code if order of column changed in SELECT SQL query, which is a major maintenance gain and a robust way to write JDBC code. Some Java programmer may argue that accessing column using index is faster than name, which is true but if you look in terms of maintenance, robustness and readability, I prefer accessing column using name in ResultSet Iterator.
JDBC Best Practice #6: Use Bind variables instead of String concatenation
In JDBC Best Practice #1 we have suggest to use PreparedStatement in Java because of better performance. But performance can only be improved if you use bind variables denoted by ? or place holders. which allows database to run same query with different parameter. This JDBC best practices also result in better performance and also provide protection against SQL injection.
JDBC Best Practice #7: Always close Statement, PreparedStatement and Connection.
Nothing new on this JDBC Best practice. Its common Java coding practice to close any resource in finally block as soon as you are done with that. JDBC Connection and other JDBC classes are costly resource and should be closed in finally block to ensure release of connection even inPreparedStatement case of any SQLException. From Java 7 onwards you can use Automatic Resource Management (ARM) Block to close resources automatically.
JDBC Best Practice #8: Choose suitable JDBC driver for your application
There are 4 typs of JDBC driver in Java and it can directly affect the performance of DAO layer. always use latest JDBC Driver if available and prefer type 4 native JDBC Drivers.
JDBC Best Practice #9: Use standard SQL statement and avoid using db specific query until necessary
This is another JDBC best practice in Java which ensures writing portable code. Since most of JDBC code is filled up with SQL query its easy to start using Database specific feature which may present in MySQL but not in Oracle etc. By using ANSI SQL or by not using DB specific SQL you ensure minimal change in your DAO layer in case you switch to another database.
JDBC Best Practice #10: Use correct getXXX() method
This is the last JDBC best practice in this article which suggest using correct getter while getting data from ResultSet to avoid data conversion even though JDBC allows to get any data type using getString()or getObject().
That’s all on JDBC best practices for Java Programmer, I am sure there are many more JDBC best practices around but these are most common practices which I can think of. let us know if you are familiar with any other JDBC best practice.
Read more: http://javarevisited.blogspot.com/2012/08/top-10-jdbc-best-practices-for-java.html#ixzz2v4Bb7P8Y