1. Objektorienteret Middleware (OOMI)
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
You will not:
Be an expert on persistence, as this is a huge area in itself

3. Outline Plenum – experince with persistent datastorage
Principles of Persistence
Datastore Technology for Persistence
Files
Relational Databases
Object Databases
Exemplified OR-mapping with EJB

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

5. Principles of Persistence

6. What is Persistence?
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
RMI & CORBA activation/deactivation
The state needs to be retained between object deactivation and object activation
Why?

7. How to achieve Persistence?
Storing object state on persistent datastore before de-activation
Upon activation, load object state from persistent datastore
As we shall see in RMI & CORBA
Persistent storage can be obtained by?
File system (Hard Drive, Disk-on-Chip, Flash Memory)
embedded systems with a disk storage
Relational Database
All from embedded, to desktop and enterprise servers (most widely used is SQL servers)
Object-Database
no widespread support yet

8. Transparency of Persistence
Persistence should be transparent to users and designers of client objects
Client Objects
Server Objects
Datastore Objects
Client
Interface
Persistence
Interface

9. C++/Java object or class
Persistence Concepts
Object
= row in
RDBMS table
C++/Java object or class
Storage
Storage Home
Objects
Incarnation
C++/Java object
Datastore
Sessions
Storage
Homes
RDBMS
Server
Storage Object
RDBMS
Table
Incarnation
C++/Java object

10. Datastore Technology for Persistence

11. Datastore Technology Persistence can be implemented using Files
CORBA Externalization
Java Serialization
Structured Storage in COM
Relational Databases
Object Relational Mappings
JDBC/ODBC
Oracle, IBM DB2, Microsoft SQL Server & Access, MySQL
Object Databases

12. How to obtain persistence?
Roll your own persistence
SOAP, RMI
For Java – use JDBC for RDBMS, serialization for filesystems
CORBA Externalization for filesystems
COM Serialization or Structured Storage
Possible to construct your own framework (e.g. ROAD)
Use a standard service
CORBA Persistence service (PSS)
COM Persistence service
Enterprise Java Beans
May still be necessary to obtain persistence manually

13. Externalization in CORBA
Technique to
write composite objects into a byte stream
load composite objects from a byte stream
Byte stream can then be written to/read from the file system
Supported by several CORBA products
Also used to store Java objects

14. Java Serialization Transforms Java objects into stream
Follows all referenced Java objects
Stream can be written onto a file to achieve persistence
Objects must implement Serializable
Attributes that need not be made persistent can be declared as transient in the class definition

15. Example of using Serialization for RMI
Class:
public class MyPersistentClass extends Activatable
This Activatable class will
Restore its State upon activation (if the file persistentObjectStore.ser exist)
Save its State after a new transaction is registered
This could also have been done utilizing an RDBMS

16. private Vector transactions; private File holder;
public MyPersistentClass(ActivationID id, MarshalledObject data)
throws RemoteException, ClassNotFoundException, java.io.IOException {
// Register the object with the activation system
// then export it on an anonymous port
super(id, 0);
// Extract the File object from the MarshalledObject that was
// passed to the constructor
holder = (File)data.get();
if (holder.exists()) {
// Use the MarshalledObject to restore my state
this.restoreState();
} else {
transactions = new Vector(1,1);
transactions.addElement("Initializing transaction vector"); }
CONSTRUCTOR of MyPersistentClass
Find complete example and tutorial at:
guide/rmi/activation/activation.4.html
Every time a passivated object is called,
the constructor is called as the rmid daemon
Instantiates it to activate – and here it
is checked whether the File exist – or not.
If it does exist, then its State is restored

17. public Vector calltheServer(Vector v) throws RemoteException {
int limit = v.size();
for (int i = 0; i < limit; i++) {
transactions.addElement(v.elementAt(i)); }
// Save this object's data out to file //
this.saveState();
return transactions;
private void restoreState() throws IOException, ClassNotFoundException {
File f = holder;
FileInputStream fis = new FileInputStream(f);
ObjectInputStream ois = new ObjectInputStream(fis);
transactions = (Vector)ois.readObject();
ois.close();
private void saveState() {
try {
File f = holder;
FileOutputStream fos = new FileOutputStream(f);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(getTransactions());
oos.close();
} catch (Exception e) {
throw new RuntimeException("Error saving vector of data");
Find complete example and tutorial at:
guide/rmi/activation/activation.4.html
Using simpel Java Serilization
To obtain perstistence

18. Persistence Interfaces in COM
IUnknown
<<Interface>>
IPersist
+ GetClassID()
<<Interface>>
<<Interface>>
<<Interface>>
IPersistStorage
IPersistStream
IPersistFile
+ IsDirty()
+ IsDirty()
+ IsDirty()
+ InitNew()
+ Load()
+ Load()
+ Load()
+ Save()
+ Save()
+ Save()
+ GetSizeMax()
+ SaveCompleted()
+ SaveCompleted()
+ GetCurFile()
+ HandsOffStorage()

19. Problems with File-based Persistence
Mapping to Files can be inefficient for large composite objects
Finder methods diffuclt to develop
Naming & File search difficult
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

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

21. Mapping to RDBMSs
Relational database schemas consist of sets of tables
Define a table for each type
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 RDMBS
secondary keys for object references
Resolve inheritance statically
This and other problems -> the OR impedance mismatch

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

23. 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
JDBC/ODBC is at a low level – but very feasible
Torque/Turbine project freeware
JDO maps to XMI
In the following EJB will be presented

24. RDBMS mapping illustrated with EJB’s

25. Enterprise JavaBeans (EJBs)
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
Enterprise Java Beans (EJB) designed for inter-process purposes

26. EJBs (cont.) Java EJB components 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)

27. EJB Architecture Interfaces and Classes Container / Application Server
beans
entity bean (maps perfectly to the “Entity stereotype”
session beans (no primary key – maps to “Control”)
Stateless session bean
Stateful session bean
GUI? JSP/Servlet or Java Application
primary key (implemented in a class)
home interface (local and remote)
EJB object interface (local and remote)
Container / Application Server

28. Bean Types Entity beans Session beans
models persistent state - this state is maintained through all method and server invocations
nouns of the domain
real world objects (e.g. Owner, Account, Transaction)
Session beans
models non-persistent state - this state will be lost between method invocations (stateless session) or server invocations (Stateful session)
manage tasks performed on behalf of a single client (e.g. Teller, Monthly Statement)
contains the business processes in which to use entity beans
manages actions that may cross entity beans or go outside the concern of an entity bean
e.g. Teller may authenticate the user and transfer funds between accounts
e.g. Statement may include transactions from multiple accounts

29. Bean Usage Entity beans Session 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 domain model (Entity classes)
Maps to Use Case model (Control classes)

30. Persistence Concepts in EJB
Storage
Storage Home
Objects
Incarnation
Datastore
Sessions
Storage
Homes
Storage Object
Incarnation

31. State Management State synchronization methods
ejbLoad
ejbStore
Resource Management methods
ejbActivate
ejbPassivate

32. 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 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

33. Bean Manged Perstistence
Have to handle all database interaction
except transactions (more of this next time)
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

34. 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: inseret
ejbRemove: delete
ejbLoad: select
ejbStore: update
ejbFindByPrimaryKey: select
And more can be implemented:
ejbFindBooksByAuthor: select

35. 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 id
title
author
topic
42123
EJB SW
43423
EJB2 …

36. 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()) {
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 { … }
...

37. 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 { … }

38. 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 { … }

39. 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 {... }

40. 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 {... }

41. RDBMS JDBC DataBean / JavaBean example from DEITEL

42. 1 // Fig : GuestBean.java
2 // JavaBean to store data for a guest in the guest book.
3 package com.deitel.advjhtp1.jsp.beans; 4
5 public class GuestBean {
private String firstName, lastName, ; 7
// set the guest's first name
public void setFirstName( String name ) {
firstName = name; } 13
// get the guest's first name
public String getFirstName() {
return firstName; } 19
// set the guest's last name
public void setLastName( String name ) {
lastName = name; } 25
// get the guest's last name
public String getLastName() {
return lastName; } 31
// set the guest's address
public void set ( String address ) {
= address;
This is another way of using JDBC access to a RDBMS. It consists of two elements, the JavaBean (code to left is a GuestBean), and a DataBean (GuestDataBean).

43. GuestBean.java 36 } 37 38 // get the guest's email address} 37
// get the guest's address
public String get () {
return ; }
43 }
GuestBean.java

44. GuestDataBean.java Set up database
1 // Fig : GuestDataBean.java
2 // Class GuestDataBean makes a database connection and supports
3 // inserting and retrieving data from the database.
4 package com.deitel.advjhtp1.jsp.beans; 5
6 // Java core packages
7 import java.io.*;
8 import java.sql.*;
9 import java.util.*; 10
11 public class GuestDataBean {
private Connection connection;
private PreparedStatement addRecord, getRecords; 14
// construct TitlesBean object
public GuestDataBean() throws Exception {
// load the Cloudscape driver
Class.forName( "COM.cloudscape.core.RmiJdbcDriver" ); 20
// connect to the database
connection = DriverManager.getConnection(
"jdbc:rmi:jdbc:cloudscape:guestbook" ); 24
getRecords =
connection.prepareStatement(
"SELECT firstName, lastName, FROM guests" ); 29
addRecord =
connection.prepareStatement(
"INSERT INTO guests ( " +
"firstName, lastName, ) " +
"VALUES ( ?, ?, ? )" );
GuestDataBean.java Set up database
Defines the database driver, URL, and SQL statements.

45. GuestDataBean.java Database access methods} 37
// return an ArrayList of GuestBeans
public List getGuestList() throws SQLException {
List guestList = new ArrayList(); 42
// obtain list of titles
ResultSet results = getRecords.executeQuery(); 45
// get row data
while ( results.next() ) {
GuestBean guest = new GuestBean(); 49
guest.setFirstName( results.getString( 1 ) );
guest.setLastName( results.getString( 2 ) );
guest.set ( results.getString( 3 ) ); 53
guestList.add( guest ); } 56
return guestList; } 59
// insert a guest in guestbook database
public void addGuest( GuestBean guest ) throws SQLException {
addRecord.setString( 1, guest.getFirstName() );
addRecord.setString( 2, guest.getLastName() );
addRecord.setString( 3, guest.get () ); 66
addRecord.executeUpdate(); } 69
// close statements and terminate database connection
Obtain the guest list from the database. Return each guest in a bean.
GuestDataBean.java Database access methods

46. GuestDataBean.java Close database
protected void finalize() {
// attempt to close database connection
try {
getRecords.close();
addRecord.close();
connection.close(); } 79
// process SQLException on close operation
catch ( SQLException sqlException ) {
sqlException.printStackTrace(); } }
85 }
GuestDataBean.java Close database

47. 71 <input type = "text" name = "email" />
</td>
</tr> 74
<tr>
<td colspan = "2">
<input type = "submit"
value = "Submit" />
</td>
</tr>
</table>
</form> 83
<% // continue scriptlet 85
} // end if
else {
guestData.addGuest( guest ); 89
%> <%-- end scriptlet to insert jsp:forward action --%> 91
<%-- forward to display guest book contents --%>
<jsp:forward page = "guestBookView.jsp" /> 94
<% // continue scriptlet 96
} // end else 98
%> <%-- end scriptlet --%>
100 </body>
101
102 </html>
Example of usage of the JavaBean/ Databean in JSP GuestBookLogin.jsp Add new guest to book
Calls the guestData Bean to write this new guest into the address book. The forward the client to the guestBookView JSP.

48. RDBMS JDBC DataBean / JavaBean
This may be better suited for WebServices / RMI
You may also employ SQL directly in your Servant objects
Also see: on how to use Torque

49. Using the Torque framework
Excerpt from tutorial – defining the Schema …
<table name="author" description="Author Table">
<column name="author_id" required="true" primaryKey="true" type="INTEGER" description="Author Id"/>
<column name="first_name" required="true" type="VARCHAR" size="128" description="First Name"/>
<column name="last_name" required="true" type="VARCHAR" size="128" description="Last Name"/>
</table>
</database>
Excerpt from tutorial – sample code
Publisher addison = new Publisher(); addison.setName("Addison Wesley Professional"); addison.save(); Author bloch = new Author(); bloch.setFirstName("Joshua"); bloch.setLastName("Bloch"); bloch.save();

50. Principles of Persistence continued ODBMS

51. ODBMS
ODBMS 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)
Support persistence of OO programming language objects

52. Mapping to ODBMSs ODL is a superset of OMG/IDL
Programming language bindings of ODBMS are also supported by CORBA
CORBA portable object adapter supports ODBMS
ODBMS objects can be
clients of CORBA objects
servers for CORBA objects

53. Comparison Externalization/Serilization Persistence in RDBMS is
only well suited for smaller size projects
Persistence in RDBMS is
complicated by OR Impedence Mismatch
simplified by wide availability of RDBMS
very performant (if OR imp.mis. is handled)
Persistence in ODBMS is
simplified by conceptual similarities of
object models
programming language bindings
but fairly unproven yet