|
Major Components
The major components in Cayenne are:
- DataAdapter
- DataObjects
- Object Graphs
- DataContext
DataAdapter
The biggest hurdle for any ORM tool is working with multiple databases. Though most databases in the market claim they follow a common standard—similar to the JDBC standard—in reality, they differ greatly from one to the other. Most databases have different sizes and precisions for common datatypes like character, number, and BLOBs and conversions between databases is not straightforward. Additionally, vendors differ in the syntax used for common transactions like outer join, primary key generation, and sequences. To overcome these differences and provide a portable framework, Cayenne provides separate data adapters for each database. The database adapter converts the vendor-specific features of the database into standard JDBC features so that they can be used by any J2EE-based application. Having a standard JDBC format shields you from having to make major changes to the code when data sources have to be swapped.
The DataAdapter acts as a factory for a specific database type. Cayenne comes packaged with adapters for common database types like Oracle, Sybase, MySQL, DB2, and SQL Server. Apart from the common databases, Cayenne has a generic database adapter called JDBCAdapter that can be used to support other databases. This adapter maps the target database's specific datatypes into standard JDBC datatypes. It also acts as a query translator that converts the generic Cayenne query into the target database's specific query. It also provides a list of features supported by the target database and facilitates primary key generation.
DataObjects
DataObjects abstract you from the complexities of the database and allows you to represent data into easy-to-understand Java objects. DataObjects represent database tables, views, and composite relationships as Java objects. DataObjects have attributes that represent the fields in the table and relationships the table has with other tables. In the case of complex DataObjects, they can also contain more DataObjects. These attributes within the DataObject can be accessed using getters and setters. If the accessed attribute is a DataObject, the corresponding DataObject with data is fetched and loaded in memory.
One of the greatest benefits of DataObjects is their ability to represent flattened relationships. Two tables that are not directly related, but are related through a join query, can be flattened and represented in a single DataObject. Cayenne takes care of the join query and keeps you abstracted from the relationships between the tables.
By default, primary and foreign keys are not represented as attributes in the DataObject. This avoids accidental modification of the primary keys. To include primary keys and foreign keys in the DataObject, you need to extend the DataObject class and write getter methods to access the keys. Cayenne provides a DataObjectUtils class to get objects for a primary key and vice-versa. Compound primary keys are also supported.
Object Graphs
The relationships between DataObjects are represented in an object graph. You create an object graph when you make a select query to retrieve data for DataObjects. As more DataObjects are fetched, their relationships are added to the existing graph. Having object graphs ensures that multiple DataObjects representing the same row in the database are not stored in memory. You can make multiple modifications on the DataObjects in the object graph and have all the changes committed to the database at the same time. If, for some reason, all the changes have to be discarded, simply deleting the object graph will do the trick.
DataContext
DataContext is the primary point of entry for your access to Cayenne functionality. The DataContext in turn interacts with the lower-level abstractions like the DataNode and DataAdapters to service user requests. It also manages the state information for the user and isolates changes between user sessions. To maintain session state, DataObjects must be registered with the DataContext. When a query is made directly through the DataContext, any DataObjects returned in the query response are automatically registered with the DataContext. When a DataObject is registered with the DataContext, it keeps a snapshot of the DataObject and tracks any changes made to it by the user. When you've finished with your modifications,call the DataContext's commitChanges() method to persist the changes to the database. The DataContext now reviews all the DataObjects registered with it and creates the select, update, create, or delete queries required for the operations. It also takes care of any primary keys that need to be generated. Once it gets a list of all the changes that are required, it orders them to honor database integrity constraints. It then begins a new transaction with the database and commits all the changes back to the database. If a problem is encountered, all the changes are rolled back and you are notified of the errors.
New on the Java Boutique:
New Review:
Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling
API boasts simplicity, ease-of-integration, a well-rounded feature
set, and it's free!
New Applet:
Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA
sequences into three useful formats.
Elsewhere on internet.com:
WebDeveloper Java
Lots of Java information on webdeveloper.com
WDVL Java
Thorough Java resource at the Web Developer's Virtual Library.
ScriptSearch Java
Hundreds of free Java code files to download.
jGuru: Your View of the Java Universe
Customizable portal with online training, FAQs, regular news updates, and tutorials.
|
