|
The CocoBase
Dynamic - Repository based O/R Mapping architecture is based on
the major industry standards, ensuring that customers have a solution
that fits their needs in an expected manner.
POJO
Data Persistence
POJO
- Sun announces new direction for data persistence with plain old
Java objects, spec. expects to be released in late 2005 or early
2006
The
CocoBase® tool offers Dynamic Transparent Persistence (i.e.
transparent to the object), both locally and distributed with an
integrated Query Manager for use with standard plain old Java Objects
that is now being referred to as Dynamic POJO Data Persistence.
POJO Data
Persistence can be defined as an unified persistence and query manager
for local J2SE and distributed J2EE environments which is completely
transparent to the object and does not require the modification
of the byte-code of the object. Enterprise JavaBeans is a distributed
method for persisting data that has proven to have some key drawbacks
that have over time limited the use quite dramatically. Java Data
Objects (JDO) is a local (non-distributed) method for persisting
data. Combining the best points of these two standards into a local
and distributed method that is transparent to the Java object is
the apparent goal of the new POJO specification. The CocoBase®
implementation of POJO Data Persistence is quite flexible and as
the new specification is clarified and finalized any changes needed
to conform should be made.
The CocoBase®
Dynamic POJO Data Persistence™ is fully portable, extensible,
and scalable. It is vendor neutral and 100% portable across J2EE/J2SE
compliant systems. There is no need for the developer to write database
specific code in order to persist objects. The transparent nature
of the persistence makes it possible to track and persist any object
type, including POJO's, EJB Entity Beans, CORBA objects, RMI objects,
and Java classes without the requirements of query language in application
code, or object model intrusion.
The CocoBase®
Dynamic POJO Data Persistence™ allows the developer to persist
relational data with a simple, non-invasive, widely distributable
object. These capabilities operate as an extensible persistence
layer - invisible to the object. Without any byte code or object
model intrusion it runs on local, as well as distributed environments,
and is designed to minimize maintenance without sacrificing performance.
It is built for both J2SE and J2EE performance. Objects are versatile
enough to be reusable, and to persist and manage objects simultaneously
across a wide number of databases. CocoBase® employs an independent
persistent monitor - invisible to the application object - which
persists, retrieves, and reconciles copies of objects to ensure
proper network programming and serialization with its persistence
facilities. The Dynamic POJO Data Persistence™ can also manipulate
multiple copies within the same JVM, so as to enable threaded servers
to have a unique context and persist on parallel transactions.
See Dynamic
POJO Data Persistence whitepaper >>
JDO
JDO
2.0 - Awaiting Finalization of the 2.0 Version to release JDO into
CocoBase.
CocoBase is
in the process of adding in an implementation of Java Data Objects
(JDO), a local (non-distributed) method for persisting data.
This can be a very good solution for customers and Thought Inc.
is excited to offer this technology.
J2EE
EJB
2.0 - Using Entity Beans
Full
support for both EJB 1.0 / 1.1 / 2.0 including CMP / BMP Entity
Beans.
CocoBase
provides complete support for the EJB component model, including
full and uncompromised support of Bean Managed Persistence (BMP)
and Container Managed persistence (CMP). We also generate standard
Java classes and EJB components, from user editable code generation
templates that are simply property files and 100% customizable as
needed.
We also generate fully optimized and portable EJBs. Since application
servers all interpret the EJB specification slightly differently,
our CMP / BMP Entity Bean Code generation helps ensure that developers
are concentrating on business logic, and not worrying if they are
coding a bean that will work properly in their server environment.
Our portable CMP installer supports more EJB servers than all other
O/R or server solutions put together. This portable CMP is so revolutionary,
that the architecture has been adopted as the J2EE specification
for how to implement CMP persistence for EJB.
CocoBase CMP
is a significant extension over built-in CMP through support of
dependent objects, built-in support for sequences and identity columns,
support for value object single network transfer of the Bean state
(remotely not just locally), real O/R mapping including the ability
to retrieve and persist a Bean to and from multiple tables and a
variety of other advanced features that turn the CMP into a solution
for the enterprise and not just a prototyping solution.
Benefits of
using CocoBase for EJB;
- CocoBase
CMP that supports a bean being persisted to multiple tables from
multiple databases, table joins and supports relationships!
- Ability
to Map all your data sources to your Enterprise Java Beans.
- Provides
a simplified layer for persisting your Java classes with EJB,
without requiring embedded JDBC & SQL calls in your objects.
- Manage
complex relationships between Entity Beans, and between Entity
Beans and non-beans (important for EJB Server performance).
- Auto
generates methods to Serialize Bean data. Between client and server
all at once, instead of an attribute at a time - essential for
enterprise scaling!
- Works
with any standard JTS service included in the EJB servers. CocoBase
doesn't require proprietary extensions to the JTS of the EJB Server
in order to ensure transactional and data integrity for either
Session Beans, BMP or CMP Entity Beans, and is fully compatible
with any of these component types.
- Support for
Sequences and Identity Columns for primary key generation of Entity
Beans.
- Support for
Proprietary SQL of databases.
- Dynamic loading
of Maps & SQL generation at runtime so BMP & CMP beans
remain completely portable across databases even when schema/table
layout is different. This feature doesn't require redeployment
or recompile unlike other less refined CMP implementations.
EJB
2.0 - NOT Using Entity Beans
For the J2EE (Enterprise
Edition) platform when customers are not using Entity Beans, there
are three other enterprise level technologies that can be used to
provide persistence. Session Beans, Java Server Pages, Servlets,
and Dynamic Transparent Persistence™ are methods for persisting
data supported by CocoBase.
Session
Bean Persistence
To use session beans with CocoBase, the bean directly calls CocoBase
facilities such as the mapping runtime, database transaction object,
navigation / transaction facilities. CocoBase provides two examples
for users that can be easily adapted their specific requirements.
The first example is an application session bean that is used for
just one application and provides the persistence needed. The second
example is a generic session bean that handles all of the persistence
for multiple applications if desired. This session bean acts like
a persistence server, easily managing all of the varied data access
and any complex relationships if they exist. We refer to this functionality
as Distributed Transparent Persistence and provide a pre-built Session
bean for this functionality.
Java
Server Page Persistence
To use Java Server
Pages with CocoBase, once the mapping of the tables and objects
is completed, CocoBase will generate the JSP for you from editable
templates. The JSP also directly calls the CocoBase facilities such
as the mapping runtime, database transaction object, and navigation
/ transaction facilities to get data persistence. An example of
using CocoBase with JSPs is available on the download page specially
built for Tomcat to demonstrate this feature. The JSP support however
is generic.
Servlet
Persistence
To use Servlets with CocoBase, once the mapping of the tables and
objects is completed, the developer copies in the code into their
servlet to provide the persistence. Since Servlets are fairly complex
to write and are greatly modified for each use, CocoBase does not
generate them, however provides a system to manage the optimizations
between the objects and relational tables necessary to increase
performance and scalability.
Dynamic
Transparent Persistence™
Persisting complex
data object graphs in both a local and distributed environment is
greatly simplified to a few lines of code. This is accomplished
dynamically thus not polluting the object graph allowing for optimal
continued reuse. It is important to compare and contrast this development
with existing systems such as ODMG and JDO. These specifications
say that the APIs are open, however, in order to achieve a practical
implementation the result becomes proprietary and vendor specific.
This means that either the class must be rewritten by hand or rewritten
by some tool to be compatible with their systems. The increased
complexity and developer time to create and maintain such a large
code base can quickly become unreasonable.
CocoBase's architecture by contrast doesn't require CocoBase code
to be inserted into the objects or the object graph. Therefore reprocessing
of source code or byte code in order to persist the objects does
not occur. Instead, the CocoBase product can persist an entire graph
of objects created elsewhere with no changes to either the object
source or binary code.
Both ODMG & JDO require changes to the source or binary code
of the objects. These approaches are both unnecessary and often
increase error-prone code to an unacceptable level. Many consider
the designs of ODMG and JDO to be counter to Java's open access
- cross platform - component reuse design intent. While CocoBase's
architecture makes Java classes vendor neutral, the other approaches
deeply tie the source or binary code to only one vendor. Their system
creates a Java class hierarchy that once processed and integrated
by one vendor becomes completely incompatible with another.
This latest generation of CocoBase's technology can identify 'copies'
of objects and parts of object graphs, and manage them in both a
local and distributed environment. Entire graphs of objects can
be copied to some remote machine, manipulated and then processed
in some form to be returned synchronized with the original and the
copy. CocoBase, using this facility, can manage virtually any serializable
object graph.
J2SE
Platform
For the standard edition of Java, CocoBase provides data persistence
in two general ways through the use of Applets and Applications.
With CocoBase the developer has full access to all of the mapping
features including Transparent Persistence (i.e. ability to map
simple to complex graphs of objects in a local and/or distributed
environments with just a few lines of code), simple to complex relationships
(i.e. one to one, one to many and many to many), and all of the
performance / scaling managed by the runtime.
Dynamic
Transparent Persistence™
Persisting complex
data object graphs in both a local and distributed environment is
greatly simplified to a few lines of code. This is accomplished
dynamically thus not polluting the object graph allowing for optimal
continued reuse.
Applets
In the typical situation the architecture used is a database, webserver
and a browser. CocoBase works between the database and the webserver
to provide persistence. CocoBase also works with Corba servers (i.e.
Orbs) and databases to provide persistence.
Applications
Using stand alone
applications, CocoBase works between the webserver and the database
to provide the data persistence.
JDBC
2.0
CocoBase®
fully supports the key features of JDBC 2.0 including JDBC 2.0 types,
JNDI connection pooling, JTS Transaction server compatibility, scrollable
cursor support, user extensible type retrieval and JDBC 2.0 meta
data retrieval. CocoBase® fully supports Blob & Clob types
for jdbc drivers that a JDBC 2.0 compliant. Some drivers use non-standard
& proprietary APIs for Blob & Clob access, so testing your
driver for compliance is recommended.
JMS
1.0
CocoBase® can persist JMS messages,
as well as leverage JMS for delivering distributed, clustered and
fault tolerant caching. CocoBase®
has expanded available caching options with an implementation of
a JMS based distributed cache that can be used with clustering for
JMS providers that support the clustering features. It is based
on the current JMS specification and integrates with any standard
third party JMS Messaging software.
The CocoBase® JMS Cache is designed
to work with any JMS 1.0 compliant messaging software stand-alone
or within the J2EE platform. As a result, the CocoBase® JMS
Cache can also work with industry leading application servers such
as BEA Weblogic, Sybase EAServer, JBoss and the Sun reference implementation
application server.
UML
XMI
CocoBase® can import and turn UML/XMI Object Models into persistence
maps, DDL and table creation and generate a complete range of abstract
Java classes, EJB components and JSPs that greatly simplifies the
complex process of mapping and persisting relational data. This
keeps developers focused on building business logic and not on hand-coding
the persistence layer. Turning a conceptual model into a concrete
application implementation has never been easier.
Users of Rational
Rose, Together Control Center, Embarcadero Describe, Sybase Power
Designer, ArgoUML, and MagicDraw Can Now Instantly Generate and
Manage Database Access Directly from the Object Model With CocoBase®.
JDK
1.4
CocoBase has implemented and tested for compliance with the newest
release of Java - JDK 1.4. The CocoBase system has been tested to
run properly with JDK 1.4 for both the CocoAdmin GUI and the CocoBase
runtime has been tested for Server usage.
|
