Objektorienteret netværkskommuniation(ITONK1)

1. Objektorienteret netværkskommuniation(ITONK1) Persistence

2. Goal with todays lesson • After these 2x35 minutes you will be: • Comfortable with the expression “persistence”, and how it relates to Distributed Systems • Knowledgeable about different strategies for obtaining persistence for Distributed Systems • Ready to explore the subject further • You will not: • Be an expert on persistence, as this is a huge area in itself

3. Outline • Plenum – experience with persistent datastorage • Continuing exercise • Principles of Persistence • Datastore Technology for Persistence • Files • Relational Databases • Examplified OR-mapping with EJB • Object Databases

4. Experience with Persistent datastorage • To establish a picture of your knowledge • Which types of persistent datastorage do you know? • What experience do you have in using it with (oo) programming languages? • What problems did you face – and how did you solve them?

5. Exercise: comparing strategies for persistence • This will be a continuing discussion • Select one or more entity classes from your own required assignment 1 an discuss how to solve the persistent requirements of the assignment using: • File persistence • Relational Database Management System (toolkit or emb. JDBC) • Object database system (ODBMS, e.g. JDO) • Using information obtained from the examples from ONK-2 and the following slides • Feel free to use the classroom PC for searching for more information • We will stop after each section (files, RDBMS, ODBMS), and allow for 5 min. group work • We will end with a follow-up discussion

6. Principles of Persistence

7. What is Persistence – a definition • Persistence is the ability of an object to survive the lifetime of the process in which it resides. • Persistence is relevant for stateful server objects. • What is State? • State = object instance attributes – private & public • Not methods • We remember the activation/deactivation discussion? • The state needs to be retained between object deactivation and object activation • Why?

8. How to achieve Persistence? • Storing object state on persistent datastore before deactivation • Upon activation, load object state from persistent datastore • E.g. RMI activation • Persistent storage can be obtained by? • File system • embedded systems on disk-storage, Flash-RAM and others • Relational Database • All from embedded, to desktop and enterprise servers (most widely used is SQL servers) • Object-Database • Has been emerging technology for years, but no widespread support yet. JDO for Java is a promising technology however • Others?

9. Datastore Technology for Persistence

10. Datastore Technology • Persistence can be implemented using • Files • CORBA Externalization • C#/Java type File Serialization • Structured Storage in COM • Relational Databases • Object Relational Mapping • “Homegrown”, CMP, JDO, Hibernate, Torque, LLBLGen Pro • JDBC/ODBC • Oracle, IBM DB2, Microsoft SQL Server & Access, MySQL • Object Databases • http://www.odmg.org/ , Versant, JDO

11. Problems with File-based Persistence • Mapping to Files can be inefficient for large composite objects • File systems only have crude support for concurrency control • File systems lack support for fault-tolerance (transactions) • Application specific code needed for every persistent class

12. Continuing exercise part 1 – file-based • Select one or more entity classes from your own required assignment 1 an discuss how to solve the persistent requirements of the assignment using: • File persistence • Pro’s and Con’s • How to implement?

13. Relational Database • Relational Database Management Systems (RDBMSs) Examples: • Ingres • Oracle • Sybase • DB2 • Microsoft SQL Server • Microsoft Access • MySQL • PostGree DB

14. Mapping to RDBMS’s • Relational database schemas consist of sets of tables • Types of mapping: • Define a table for each type • Complex mapping • In each table create • primary key for object identifier • a column for each attribute of the object • mapping of middleware atomic types to primitive types supported by RDBMS • secondary keys for object references • Resolve inheritance statically • This and other problems -> • Objects and RDBMS does not map perfectly: • the OR impedance mismatch

15. Embedding Queries into Programs • Embedded SQL • Macros to embed queries into programs • RDBMS provides processor to expand macros • API to traverse queries • Not standardized • Open Database Connectivity (Microsoft) • Standardized API for RDBMS Access available on all Microsoft Platforms • Java Database Connectivity (Sun) • Standardized RDBMS Access from Java

16. Issues with mapping • Does this mean that we should figure out for ourselfes how to obtain the OR-mapping? • No • Frameworks available • CORBA PSS, COM persistence, EJB for Java, CCM, Hibernate, others • JDBC is at a low level • Hibernate project freeware

17. RDBMS mapping illustrated with EJB’s

18. Enterprise JavaBeans (EJB’s) • Standard server-side component model for Java Enterprise Applications • security • resource pooling • persistence • concurrency • transactional integrity • Has nothing to do with “JavaBeans” • JavaBeans designed for intra-process purposes • GUIs, non-visual widgets, entity representations • Enterprise Java Beans (EJB) designed for inter-process purposes

19. EJB’s (cont.) • Restricted to Java (only implementation language) • platform independence • “write once, run anywhere” • EJB components • platform/implementation independence • write once, run in any Application Server complying with the EJB spec • J2EE reference implementation • Oracle’s Application Server (OAS) • IBM’s Websphere • BEA’s Weblogic Server and Weblogic Enterprise • Sybase’s EAServer • Open Source – JBoss (see links)

20. Bean Usage Maps to domain model (Entity classes) • Entity beans • model state maintained across all client interactions • represent a row of data in a database • Session beans • model business process being performed by a single client involving one or more entity beans • it extends the actions of the client into the server • simplifies the actions programmed by the client • limits the number of distributed calls required between the client and the entity beans • limits the number of stubs that have to be loaded by the client • are not persisted to a database Maps to Use Case model (Control classes)

21. Entity Bean Types • Bean can have total control over loading and storing from database • Bean Managed Persistence (BMP) • Container can take over this responsibility • Container Managed Persistence (CMP) • Still need to define an OR mapping in admin tool • This is the same in CORBA CCM / PSS • Specialized Implementations • Legacy applications such as CICS • When to choose what? • Well – start out with CMP if possible, and then migrate code as performance issues pops up during testing

22. Bean Managed Persistence • Have to handle all database interaction • except distributed transactions • ejbLoad() and ejbStore() called when bean instance state must be synchronized with database • ejbActivate() and ejbPassivate() called when bean is moved between the ready state and pooled state

23. Implement a BMP Entity Bean package java.examples.ejb.entity.bean; import javax.ejb.EntityBean; import javax.ejb.EntityContext; … public class BookBMP extends BookEJB { private DataSource dataSource_; private EntityContext ctx_; … Additional setup of database connections needed – some are done in the configuration tool • Important features: Entity beans always implement the following event handles: • ejbCreate: insert • ejbRemove: delete • ejbLoad: select • ejbStore: update • ejbFindByPrimaryKey: select • And more can be implemented: • ejbFindBooksByAuthor: select

24. Implement DB Insertion public String ejbCreate(String id, String title, String author, String topic) { super.ejbCreate(id, title, author, topic); Connection conn = null; PreparedStatement pstatement = null; try { conn = dataSource_.getConnection(); pstatement=conn.prepareStatement("insert into Book (id, title, author, topic)"+ ” values (?, ?, ?, ?)"); pstatement.setString(1,id_); pstatement.setString(2,title_); pstatement.setString(3,author_); pstatement.setString(4,topic_); pstatement.execute(); return id_; } catch(SQLException ex) { throw new EJBException(ex); } finally { … } } BookBMP OR-mapping

25. Implement DB Load public void ejbLoad() { Connection conn = null; PreparedStatement pstatement = null; ResultSet rs = null; try { conn = dataSource_.getConnection(); pstatement = conn.prepareStatement( "select id, title, author, topic from Book " + "where id = ?"); pstatement.setString(1, (String)ctx_.getPrimaryKey()); rs = pstatement.executeQuery(); if (rs.next()) { if (rs.next()) { id_ = rs.getString("id"); title_ = rs.getString("title"); author_ = rs.getString("author"); topic_ = rs.getString("topic"); super.ejbLoad(); } else { throw new EJBException("unable to locate row"); } } catch(SQLException ex) { throw new EJBException(getText(ex)); } finally { … } …

26. Implement DB Store public void ejbStore() { Connection conn = null; PreparedStatement pstatement = null; try { super.ejbStore(); conn = dataSource_.getConnection(); pstatement = conn.prepareStatement( "update Book set title=?, author=?, topic=? " + "where id = ?"); pstatement.setString(1,title_); pstatement.setString(2,author_); pstatement.setString(3,topic_); pstatement.setString(4,id_); pstatement.executeUpdate(); } catch(SQLException ex) { throw new EJBException(getText(ex)); } finally { … } }

27. Implement DB Remove public void ejbRemove() { Connection conn = null; PreparedStatement pstatement = null; try { super.ejbRemove(); conn = dataSource_.getConnection(); pstatement = conn.prepareStatement("delete from Book " + "where id = ?"); pstatement.setString(1, (String)ctx_.getPrimaryKey()); pstatement.executeUpdate(); } catch(SQLException ex) { throw new EJBException(getText(ex)); } finally { … } }

28. Implement Finders public String ejbFindByPrimaryKey(String pk) throws FinderException { Connection conn = null; PreparedStatement pstatement = null; ResultSet rs = null; try { conn = dataSource_.getConnection(); pstatement = conn.prepareStatement("select id from Book " + "where id = ?"); pstatement.setString(1, pk); rs = pstatement.executeQuery(); if (rs.next()) { return rs.getString("id"); } else { throw new ObjectNotFoundException(pk + " no found"); } } catch(SQLException ex) { throw new EJBException(getText(ex)); } finally {... } }

29. Implement Finders (cont.) public Collection ejbFindAll() throws FinderException { Connection conn = null; PreparedStatement pstatement = null; ResultSet rs = null; try { Vector pKeys = new Vector(); conn = dataSource_.getConnection(); pstatement = conn.prepareStatement("select id from Book "); rs = pstatement.executeQuery(); while (rs.next()) { pKeys.add(rs.getString("id")); } return pKeys; } catch(SQLException ex) {throw new EJBException(getText(ex)); } finally {... } }

30. Continuing exercise part 2 – RDBMS based • Select one or more entity classes from your own required assignment 1 an discuss how to solve the persistent requirements of the assignment using: • RDBMS • Embedded SQL • If you have experience using toolkits, be free to elaborate on this • Pro’s and Con’s • How to implement • Compared to using file externalization

31. Principles of Persistence continuedODBMS

32. ODBMS • ODBMSs have been standardized by the Object Database Management Group • Schema definition language (ODL) – subset of CORBA IDL • Programming language bindings to • C++ • Java • And many others • Object Query Language (OQL) • JDO has replaced the Java binding • Support persistence of OO programming language objects

33. JDO: POJO’s

34. Continuing exercise part 3 – ODBMS based • Select one or more entity classes from your own required assignment 1 an discuss how to solve the persistent requirements of the assignment using: • ODBMS • Use the JDO example from ONK-2 • Pro’s and Con’s • How to implement? • Compared to using RDBMS and file externalization

35. Comparison • File externalization / serialization is not transparent for implementors of server objects • Persistence in RDBMS’s is • complicated by OR-impedance mismatch • simplified by wide availability of RDBMS’s • Well-known tested technology • Persistence in ODBMS’s is • simplified by conceptual similarities of • object models • programming language bindings • No widespread support • (personal view) I would not risk high-performance system on this