JDBC Overview. Java Database Connectivity. Gregg Lippa Senior Technical Analyst Themis Education Themis, Inc.

Transcription

1 JDBC Overview Java Database Connectivity Gregg Lippa Senior Technical Analyst Themis Education Themis, Inc. Visit us at: Also:

2 This Webinar Addresses These Questions How do you access relational data in Java using JDBC? What is a JDBC driver and how do you use it? How do you make a connection to a database? What are Statements and PreparedStatements? How do prepared statements improve performance? How do you process database query results? How do you handle JDBC exceptions and warnings? How do you call stored procedures using JDBC? How does JDBC support database transactions? How do you specify isolation levels via JDBC? What are ORM, JPA and Hibernate and what do they do? We will have very little time for questions Please submit questions via to glippa@themisinc.com 2

3 Static SQL vs Dynamic SQL Static SQL: compiled and bound to database during application development Dynamic SQL: compiled and optimized at runtime Increases total statement execution time Errors in the SQL statement not detected until runtime Benefits of Static SQL Compile at bind time allows for efficient access path/plan selection Security can be applied at the plan level Disadvantages of Static SQL Need to bind before runtime and manage plans that are created JDBC does not provide support, except through Stored Procedures SQLJ does support this but is not widely used (nor covered today) 3

4 Static SQL vs Dynamic SQL Benefits of Dynamic SQL IDEs and APIs such as Eclipse and JDBC support dynamic SQL Better statistics because the statement is compiled at runtime Uses the latest statistics available May result in a better execution plan Disadvantages of Dynamic SQL Compile at runtime can be a problem for several reasons: Every time a statement is executed, it needs to be compiled, which increases the total statement execution time Since the compile time figures into the total execution time, even with higher optimization levels, overall performance may degrade instead of improving Because the SQL statement is not compiled until runtime, errors in the SQL will not be detected until runtime To summarize: Use Static SQL if security and/or performance is your major concern Use Dynamic SQL if ease of development is your main concern 4

5 Stored Procedures Precoded SQL, usually contained within programming logic Supports static SQL when using JDBC Highly recommended in the financial industry Less vulnerable to attacks Can be written with static SQL JDBC can be used to call Stored Procedures We will see how to call a Stored Procedures using JDBC We will not see how to write the actual Stored Procedure (SP) Each DBMS provides its own language support for writing SPs Some SPs can be written in commercial languages, such as COBOL 5

6 JDBC: Java Database Connectivity Trademarked name of technology written by Sun Now owned by Oracle Framework composed mainly of interfaces Defined by Sun and implemented by database drivers Same functionality available regardless of driver Switching databases should require minimal code changes Java Application Programming Interface (API) Provides access to any type of tabular data Normally used to access Relational Databases Vendor independent Allows Java applications to easily Connect to data source Create and execute queries and updates Retrieve and process query results 6

7 JDBC: Three-tier Architectures Three-tier Architecture for Data Access Client HTML Browser or Java Applet HTTP, RMI, CORBA Application Server Java Application or Servlet JDBC API Browser communicates with a middle tier which in turn communicates with data source Driver DBMS-Proprietary Protocol Database Server DBMS 7

8 JDBC Drivers Java Application Code JDBC Driver Manager JDBC-ODBC Bridge ODBC Driver Manager ODBC Driver (MS Access) ODBC Driver (MySQL) JDBC Driver (Oracle) JDBC Driver (DB2) DBMS (Access) DBMS (MySQL) DBMS (Oracle) DBMS (DB2) 8

9 Database Access Overview 1. Obtain connection to data source Load and use a database driver to connect Alternatively, use connection pooling (later) 2. Perform database activities Create a JDBC Statement object Execute SQL performing query or update Retrieve and process query results or retrieve update counts 3. Terminate connection to data source Close all database-related objects 9

10 Load Database Driver Connecting to a data source requires an appropriate database driver Driver is specific to database being used Usually provided by database vendor forname: static method defined in Class class Takes one parameter: name of the driver class Loads the specified database driver class Results in registration of driver with DriverManager May throw ClassNotFoundException Examples: try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); catch(classnotfoundexception e) { // handle problem loading driver here Load Sun s JDBC-ODBC bridge driver try { Class.forName("com.ibm.db2.jcc.DB2Driver"); catch(classnotfoundexception e) { // hadle problem loading DB2 driver here Load DB2 driver 10

11 Connect to Data Source DriverManager class provides services for managing drivers DataSource provides alternative way to connect (more later) Use its static getconnection method to open connection Returns a Connection object supporting specified database URL Throws SQLException if problem connecting Optionally accepts userid and password parameters Database URL depends on driver being used URL consists of: jdbc:subprotocol:subname jdbc subprotocol subname Main Protocol Driver specific Driver specific Connection conn = null; try { conn = DriverManager.getConnection( "jdbc:dburl:dbname","dbid","dbpw"); catch(sqlexception e) { // handle database connection problems Open connection to database providing an id and password 11

12 Connecting to Data Source Example import java.sql.*; public class MySQLConnect { public static void main(string [] args) { System.out.println("DB2 Connect Example."); Connection conn = null; String dburl = "jdbc:db2://p390.themisinc.com:50000/db1a"; String driver = "com.ibm.db2.jcc.db2driver"; String username = "user1"; //never hard code String password = "mypasswd"; //in your program try { // load driver and get connection Class.forName(driver); conn = DriverManager.getConnection(dburl, username, password); // this is where you use the database connection now available System.out.println("Successfully connected to DB: " + dburl); catch(classnotfoundexception e) { System.err.println("Cannot find JDBC Driver named " + driver); catch(sqlexception e) { System.err.println("Cannot make Connection to " + dburl); finally { try { // explicitly close Connection when finished to release resources conn.close(); System.out.println("Disconnected from database"); catch(sqlexeception e) { System.err.println("Close error for " + dbname + e.getmessage()); 12

13 Create Statement Connection provides createstatement method Returns Statement object used to interact with the database via SQL May throw SQLException Accepts two optional configuration parameters supporting: 1. Scrollable cursors 2. Updateable ResultSets Example: // Create Statement for sending SQL to database Statement stmt = null; try { Defaults to a cursor that is stmt = conn.createstatement(); forward only and read only catch(sqlexception e) { // handle problem creating statement 13

14 Executing SQL Statement object is used to execute SQL on database Use executequery method to execute database query (SELECT) Passed a parameter containing SQL to execute Returns a ResultSet object for processing selected rows Returns empty ResultSet object if nothing selected Use executeupdate method to modify database Both methods are defined in Statement Passed a parameter containing SQL to execute (non-select) Returns int corresponding to: Row count for DML statements (INSERT, UPDATE, DELETE) Zero (0) for DDL statement (CREATE, ALTER, DROP, etc.) ResultSet rs = null; int rowcount = 0; try { rs = stmt.executequery("select * from Product Where name like 'S%'"); rowcount = stmt.executeupdate("delete from Product where id = 1234"); catch(sqlexception e) { // handle problems executing SQL 14

15 Result Sets ResultSet object is returned from executequery method May be Scrollable and/or updateable depending on how Statement was created Optional parameters may be passed to createstatement If parameters omitted, createstatement defaults to TYPE_FORWARD_ONLY and CONCUR_READ_ONLY ResultSet types available: TYPE_FORWARD_ONLY (Default) TYPE_SCROLL_INSENSITIVE TYPE_SCROLL_SENSITIVE Result set not scrollable Cursor moves forward only (from before first row to after last row) Most efficient Result set scrollable (cannot see concurrent changes made by others) Cursor can move both forward and backward relative to current position (relative method) Cursor can move to absolute position (absolute method) Result set scrollable (can see concurrent changes made by others) Cursor can move both forward and backward relative to current position (relative method) Cursor can move to absolute position (absolute method) Least efficient (avoid if possible) ResultSet concurrencies: CONCUR_READ_ONLY (Default) CONCUR_UPDATABLE Result set may not be updated Result set may be updated 15

16 Cursor Positioning ResultSet supports cursor positioning Columns are retrieved from row referenced by cursor Cursor initially positioned before first row (no data available) Scrollable cursors support unlimited movement Cursor positioning methods of ResultSet Only the next() method is available by default Cursor Positioning Method boolean next() boolean previous() boolean first() boolean last() void beforefirst() void afterlast() boolean relative(int rows) boolean absolute(int row) Effect on Cursor Moves cursor forward one row from current position Moves cursor up (backwards) to previous row Moves cursor to first row Moves cursor to last row Moves cursor to front (just before first row) Moves cursor to end (just after last row) Moves cursor relative to current position Positive value moves cursor forward Negative value moves cursor backward Moves cursor to specified row number Positive moves cursor with respect to beginning Negative value moves cursor with respect to end 16

17 Cursor Positioning Example Statement sql = null; ResultSet rs; sql = conn.createstatement(resultset.type_scroll_insensitive, ResultSet.CONCUR_READ_ONLY); rs = sql.executequery("select * From Product"); // position cursor after last row rs.afterlast(); // process ResultSet from back to front while(rs.previous()) { // process current row here rs.absolute(4); rs.relative(-2); rs.relative(3); Scrollable cursor created so all positioning methods are available previous method returns false when the cursor is positioned before 1 st row 17

18 Column Retrieval ResultSet defines getter methods to retrieve column values Column values individually retrieved using either: String containing column name (not case sensitive) int containing column number (position in SELECT statement) JDBC type converted to Java type by driver if possible Use appropriate method depending on data type getstring can convert simple types to String value Examples: Getter Method JDBC Type Java Type getstring [VAR]CHAR String getdouble DOUBLE double getfloat FLOAT float getbigdecimal NUMERIC BigDecimal getbigdecimal DECIMAL BigDecimal getlong BIGINT long getint INTEGER int getshort SMALLINT short getbyte TINYINT byte getboolean BIT boolean getbytes [VAR]BINARY byte [] getdate DATE java.sql.date gettime TIME Time gettimestamp TIMESTAMP Timestamp getsqlxml SQLXML java.sql.sqlxml // get column cost as BigDecimal value BigDecimal price = rs.getbigdecimal("cost"); // get 3 rd column in SELECT as String value String name = rs.getstring(3); JDBC Types are defined in java.sql.types 18

19 Result Sets Handling Null Values Column values retrieved from a ResultSet may be null The getxxx methods of ResultSet will set the variable receiving the value to Null if it is a reference variable (e.g. BigDecimal, String, Date) Zero (0) if it is a primitive type variable Methods like getdate and getstring will therefore possibly return null Testing for null values in the column is simply a matter of checking for null Methods like getdouble and getint return zero if column value was null No SQLException is thrown For primitive type data, use the wasnull method after the getxxx call Returns a boolean indicating whether the last column read had a value of SQL null This call must be the next call made to the ResultSet following the getxxx call // BigDecimal column cost may be null BigDecimal price = rs.getbigdecimal("cost"); if (price == null) { /* handle null value here */ // Integer column quantity may be null double qty = rs.getdouble("quantity"); if (rs.wasnull()) { /* handle null value here */ 19

20 Updatable Result Sets Update methods are available to update columns in result set Provided in ResultSet but not supported by all drivers and DBMS JDBC type determines method Updates apply to current row (based on cursor position) Modifies ResultSet (not database table) updaterow causes update of row in database table cancelrowupdates cancels (prevents) update deleterow deletes row from ResultSet and database Update method parameters include: Column label (name) or index Column value (same type as in DB) Update method examples for int: myrs.updateint(3, 1000) myrs.updateint("quantity", 25) An update method exists for each supported JDBC type 20

21 Updatable ResultSet Example int quantity; Statement stmt; ResultSet rs; stmt = conn.createstatement(resultset.type_forward_only, rs = stmt.executequery( "Select * from Product"); while(rs.next()) { quantity = rs.getint("qtyonhand"); quantity += 10; rs.updateint("qtyonhand", quantity); rs.updaterow(); ResultSet.CONCUR_UPDATABLE); Statement must be created as CONCUR_UPDATABLE Select must access single table only 21

22 Complete JDBC Example package jdbc; public class UseDatabase { public static void main(string[] args) { System.out.println("Using Access database"); ProductTable accessdb = new ProductTable( "jdbc:odbc:javaapp", "sun.jdbc.odbc.jdbcodbcdriver"); accessdb.createconnection(); accessdb.insertproduct(123, "Uni Widget", 10); accessdb.insertproduct(456, "Left Widget", 3); accessdb.insertproduct(789, "Right Widget", 6); accessdb.showallproducts(); accessdb.shutdown(); OUTPUT Using Access database row inserted for Uni Widget row inserted for Left Widget row inserted for Right Widget ID Name Quantity Uni Widget Left Widget Right Widget 6 System.out.println("\nUsing DB2 database"); ProductTable mydb2 = new ProductTable( "jdbc:db2://p390.themisinc.com:50000/db1a", "com.ibm.db2.jcc.db2driver"); mydb2.createconnection("user1", "mypasswd"); mydb2.insertproduct(123, "Uni Widget", 10); mydb2.insertproduct(456, "Left Widget", 3); mydb2.insertproduct(789, "Right Widget", 6); mydb2.showallproducts(); mydb2.shutdown(); Methods being called in above code are defined on the 4 following pages Using DB2 database row inserted for Uni Widget row inserted for Left Widget row inserted for Right Widget ID Name Quantity Uni Widget Left Widget Right Widget 6 22

23 ProductTable Class and Constructor package jdbc; import java.sql.*; public class ProductTable { private String dburl = null; private String driver = null; private Connection conn = null; private Statement stmt = null; public ProductTable( String dburl, String driver) { this.dburl = dburl; this.driver = driver; Access DB2 dburl jdbc:odbc:javaapp jdbc:db2://p390.themisinc.com:50000/db1a driver sun.jdbc.odbc.jdbcodbcdriver com.ibm.db2.jcc.db2driver 23

24 Overloaded createconnection public void createconnection() { try { // load driver and connect to database Class.forName(driver); conn = DriverManager.getConnection(dbURL); catch(classnotfoundexception e) { System.err.println("Driver load error: " + e.getmessage()); e.printstacktrace(); catch(sqlexception e) { System.err.println("DB connect error: " + e.getmessage()); e.printstacktrace(); public void createconnection(string userid, String password) { try { // load driver and connect to database Class.forName(driver); conn = DriverManager.getConnection(dbURL, userid, password); catch(classnotfoundexception e) { System.err.println("Driver load error: " + e.getmessage()); e.printstacktrace(); catch(sqlexception e) { System.err.println("DB connect error: " + e.getmessage()); e.printstacktrace(); 24

25 showallproducts Method public void showallproducts() { try { stmt = conn.createstatement(); ResultSet rs = stmt.executequery("select * from Product"); System.out.println("\nID Name Quantity"); System.out.println(" "); while(rs.next()) { System.out.print(rs.getInt("id") + "\t"); System.out.print(rs.getString("name") + "\t"); System.out.println(rs.getInt(3)); catch(sqlexception e) { System.err.println("DB statement error: " + e.getmessage()); e.printstacktrace(); finally { try { if (rs!= null) rs.close(); if (stmt!= null) stmt.close(); catch(sqlexception e) { /* handle it */ 25

26 public void insertproduct(int id, String name, int quantity) { try { // delete it first, then insert stmt = conn.createstatement(); String sql = "delete from product where id = " + id; insertproduct and shutdown stmt.executeupdate(sql); sql = "insert into product values (" + id + ", '" + name + "', " + quantity + ")"; if (stmt.executeupdate(sql) == 1) { System.out.println("row inserted for " + name); catch(sqlexception e) { System.err.println("DB error: " + e.getmessage()); e.printstacktrace(); finally { try { if (stmt!= null) stmt.close(); catch(sqlexception e) { /* handle it */ public void shutdown() { try { if(conn!= null) conn.close(); catch(sqlexception e) { /* handle it, e.g. log it */ close releases database and JDBC resources Executes the insert and checks for success 26

27 Method to Produce a List of Products public List<Product> getproductlist() { try { List<Product> productlist = new ArrayList<Product>(); stmt = conn.createstatement(); ResultSet rs = stmt.executequery("select * from Product"); while(rs.next()) { Product p = new Product(); Create a product object p.setid(rs.getint("id")); p.setname(rs.getstring("name")); Populate it with data p.setquantity(rs.getint("quantity")); from the current row productlist.add(p); Add it to the List that will be returned to the caller catch(sqlexception e) { System.err.println("DB statement error: " + e.getmessage()); finally { try { if (rs!= null) rs.close(); if (stmt!= null) stmt.close(); if (conn!= null) conn.close(); catch (SQLException e) { /* handle it */ return productlist; // sample call to the above method List<Product> theresults = null; theresults = getproductlist(); for (Product p : theresults) {... 27

28 PreparedStatement Interface PreparedStatement precompiles SQL for repeated use SQL is supplied when PreparedStatement created Unlike Statement, which receives its SQL at execution time Supplied SQL may contains one or more question marks (?) These are placeholders for parameters which must be supplied Calls to setxxx methods specify their values Create via preparestatement method of Connection Requires the SQL statement as a parameter Optionally supports scrollability and updateability String sql = "Select * From Product Where name =?" PreparedStatement pstmt = conn.preparestatement(sql); pstmt.setstring(1, "Left Widget"); ResultSet rs = pstmt.executequery(); 28

29 PreparedStatement To Delete Rows public void deleterows() { int totaldeleted = 0; try { // 2 parameters specified (one int and one String) String sql = "Delete From Product Where id =? AND name =?"; PreparedStatement pstmt = conn.preparestatement(sql); // file toberemoved.txt contains id and name to be deleted BufferedReader in = new BufferedReader(new InputStreamReader( new FileInputStream("toBeRemoved.txt"))); String number = null; while((number = in.readline())!= null) { int id = Integer.parseInt(number); String name = in.readline(); // Use file input to set all parameter values pstmt.setint(1, id); pstmt.setstring(2, name); int deletecount = pstmt.executeupdate(); totaldeleted += deletecount; catch(exception e) { /* error handling here */ System.out.println("\nTotal rows deleted: " + totaldeleted); try { if (in!= null) in.close(); catch(ioexception e) { /* error handling here */ readline returns null on EOF Returns number of rows deleted INPUT FILE CONTENTS: 123 Uni Widget 789 Right Widget 29

30 Connection Pooling Application threads share connections Only need connection during processing of transaction Connection needed for a relatively short time Connection can then be used by another thread Benefits of connection pooling Greatly increases performance of applications Reduces connection creation time Simplifies programming Reduces resource usage May improve licensing costs Simplifies switch to a different DBMS Managed by a Java EE server Typically created using server s administrative tools Obtained via JNDI lookup Java Naming and Directory Interface 30

31 Connection Pooling Example import javax.naming.*; import javax.sql.datasource; public void createconnection(string userid, String password) { String datasourcename = "jdbc/dsnamesetbyadministrator" String localdatasourcename = "java:comp/env/jdbc/mydsname" try { Context ctx = new InitialContext(); DataSource ds = (DataSource) ctx.lookup(datasourcename); Connection conn = ds.getconnection(userid, password); catch(namingexception e) { /* handle exception relating to JNDI naming issue */ catch(sqlexception e) { /* handle exception relating to SQL error */ // alternative: use locally defined name to lookup DataSource DataSource ds = (DataSource) ctx.lookup(localdatasourcename); 31

32 Error Handling SQLException is a specific kind of Exception Provides additional methods specific to database access Method String getsqlstate() int geterrorcode() String getmessage() Returns Standard SQLState value Vendor-specific SQLCode value Vendor-specific error message (inherited from Throwable class) try { // SQL database work here catch(sqlexception sqle) { StringBuilder out = new StringBuilder("** SQL Error Information **\n"); out.append("sql State: ").append(sqle.getsqlstate()).append("\nerror Code: ").append(sqle.geterrorcode()).append("\nmessage: ").append(sqle.getmessage()); System.err.println(out); OUTPUT ** SQL Error Information ** SQL State: Error Code: 1049 Message: Unknown database 'unknown' 32

33 Processing Warnings SQLWarning is a specific kind of SQLException Indicates less severe SQL problem or status Warnings are not thrown (do not stop execution) They are chained silently to generating object Connection, Statement, ResultSet Must be explicitly requested using appropriate method getwarnings() returns the first SQLWarning getnextwarning() returns the next SQLWarning in the chain String dburl = "jdbc:odbc:javaclass"; Connection conn = DriverManager.getConnection(dbURL); Statement stmt = conn.createstatement(); // Process warnings on Connection object SQLWarning w = conn.getwarnings(); StringBuilder out = new StringBuilder("** SQL Warning Info **"); while(w!= null) { out.append("\nstate: ").append(w.getsqlstate()).append("\nerror Code: ").append(w.geterrorcode()).append("\nmessage: ").append(w.getmessage()); w = w.getnextwarning(); System.err.println(out); 33

34 Using Finally JDBC connects to external resources Not garbage collected Must be explicitly released to avoid potential problems close() method of connection release resources By closing the database connection Use finally block to ensure database connection is closed try { // open connection; access database; etc. catch(sqlexception e) { // process errors here finally { try { if (conn =! null) { conn.close(); catch(sqlexception e) { /* handle it */ 34

35 Calling Stored Procedures Stored Procedures (SPs) are named SQL stored in the database Provides performance and security benefits Application makes database request with simple call JDBC's CallableStatement supports executing SPs Supports IN, OUT, and INOUT parameters via placeholders (?) OUT and INOUT parameters must be registered with a type Zero or more ResultSets may be returned from a SP Use Connection interface method preparecall Requires an SQL statement containing the SP call syntax Returns a CallableStatement referring to the SP Three methods to execute Stored Procedures: executequery(), executeupdate(), execute() 35

36 Callable Statement Example public String getnameforthisid(int idtofind) { // variables used for parameter values // idtofind sent to stored procedure as IN parameter // name returned by stored procedure as OUT parameter String name = null; try { // two parameters required one int and one String // first parameter provides an id to search for and // second one receives the name for that id after execution // Escape syntax for stored procedure enclosed in curly braces. // Driver translates escape syntax into native SQL // used by database to call stored procedure. CallableStatement cstmt = conn.preparecall( " { call spownerid.getname (?,? ) " ); // set IN parameter to value of idtofind cstmt.setint(1, idtofind); // register OUT parameter as JDBC type VARCHAR cstmt.registeroutparameter(2, Types.VARCHAR); // execute the stored procedure cstmt.execute(); // retrieve value of OUT parameter as String name = cstmt.getstring(2); catch(sqlexception e) { /* handle it here */ finally { /* close connection here */ return namevalue; 36

37 Transaction Processing Most business operations require transactions Transaction: a group of related database updates Often requires multiple SQL statements All updates must succeed to achieve valid result AutoCommit is true by default Data modifications are committed immediately Use setautocommit method in Connection passing value false Turns off autocommit; transactions are then managed by methods of Connection: commit() - Finalize group of updates (make permanent) rollback() - Undo all updates since previous commit Note: With auto-commit turned off, closing a pooled connection will NOT automatically commit or roll back. Uncommitted updates will become part of the transaction of the next process that receives that connection object after its return to the pool. public class UseTransactionalUpdates { public static void main(string[] args) throws Exception { try { // load driver and get connection (not shown) conn.setautocommit(false); stmt = conn.createstatement(); stmt.executeupdate("delete from product where id = 123"); stmt.executeupdate("insert into product values (123, 'test', 20)"); conn.commit(); catch(sqlexception e) { try { conn.rollback(); catch(sqlexception e1) {/* handle it */ 37

38 Isolation level Isolation Levels Determines database locking characteristics of read operations Cannot be changed after a transaction has started on the connection All levels may not be supported by a given DBMS Use Connection methods to change and retrieve isolation level void settransactionisolation(int); int gettransactionisolation(); Isolation levels defined as constants in Connection interface: Isolation Level TRANSACTION_NONE TRANSACTION_READ_COMMITTED TRANSACTION_READ_UNCOMMITTED TRANSACTION_REPEATABLE_READ TRANSACTION_SERIALIZABLE Meaning Transactions not supported Dirty reads prevented Non-repeatable and phantom reads can occur Dirty, non-repeatable and phantom reads can occur Dirty and non-repeatable reads prevented Phantom reads can occur Dirty, non-repeatable and phantom reads prevented conn.settransactionisolation(connection.transaction_read_committed); 38

39 Object Relational Mapping (ORM) A Very Brief Introduction

40 Persistence of Objects: A Paradigm Mismatch Business data is usually stored and "persists" in a relational DBs Applications use SQL to store and retrieve the data Typically embedded within a programming language Object-oriented languages like Java support relational data access However, table rows and Java objects have different structures An object's fields must be mapped to a table's columns Objects participate in various relationships with other objects Inheritance, polymorphism, composition, collections, etc. Object identity and table identity may also differ, raising issues This is known as the object/relational paradigm mismatch Overcoming it has a cost Much Java code is often required to manually bridge the gap So....

41 Object Relational Mapping (ORM) ORM automates persistence of Java objects to relational tables Uses metadata to describe the mapping of objects to database tables Transparently transforms data from one representation to the other What does an ORM solution do? Specifies mapping metadata Performs CRUD on objects of persistent classes Supports queries that refer to classes and their properties Provides transaction support and optimization capabilities What issues are addressed by ORM? Design, definition and lifecycle of persistent classes Mapping class inheritance hierarchies to table structures Facilities for searching, sorting, and aggregating Runtime interaction between persistence logic and business objects Efficiency, especially when using joins to navigate an object graph

42 Why Use ORM? Reduces the time-consuming work of perisistence-related code Allows developers to concentrate on the business problems Reduces the amount of code required Makes the system more understandable and easier to maintain Focuses developers on business logic rather than plumbing Often improves performance Many performance optimizations are provided by ORM settings Equal performance is possible without ORM but requires greater developer expertise and additional development time Insulates application from underlying database ORM implementations typically support many DBMSs Simplifies the task of changing database vendors

43 Java Persistence API (JPA) ORM is now part of the Java specification known as JPA Maps Java classes to database tables Maps Java data types to SQL data types Provides data query and retrieval facilities Generates the SQL calls and submits them at the optimal time Relieves developer from manually creating objects from result sets Delivers database portability with very little performance overhead Hibernate is a popular open source ORM Available since 2003 Implements the JPA specification Also provides numerous extensions Other ORM implementations EclipseLink (was Oracle TopLink ) OpenJPA Many more

44 Where Do I Go From Here?

45 Learning More About Java, OO and Database Interaction Java 1 (Intro Java) and Java 2 (Intermediate Java) These courses spend two weeks in Java Standard Edition Both courses are necessary to get a complete background Java Enterprise Servlets and JSPs One week course on these critical components of Java EE Object Oriented Analysis and Design This course gives the budding OO developer a solid background in OO requirements specification and UML Many other courses depending on your environment Enterprise Java Beans (EJBs); Java Persistence API (JPA); Java Messaging Service (JMS); Java Server Faces (JSF); Web Services with Java; Design Patterns; Spring; XML; HTML; Hibernate; Struts; many more 45

46 Batch Java Execution (future webinar stay tuned)

47 Thank you for coming US Intl On-site and Public Instructor-led Hands-on Training Over 400 IT Courses Customization Available