Developing with CocoBase - PowerPoint PPT Presentation


PPT – Developing with CocoBase PowerPoint presentation | free to view - id: 137400-NjMwY


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation

Developing with CocoBase


Relationships are somewhat auto-detected and auto-mapped to relational tables ... Reflection can auto detect public attributes or private attributes with public ... – PowerPoint PPT presentation

Number of Views:75
Avg rating:3.0/5.0
Slides: 84
Provided by: johns66


Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: Developing with CocoBase

E141CocoBase, EA Server and PowerDesigner -
Abstracting the Database Layer
  • Ward Mullins
  • CTO
  • THOUGHT Inc.

Developing with CocoBase
  • The strengths of CocoBase Enterprise O/R are
    its market leadership and features such as
  • JAVA Object ? Relational (RDBMS) mapping tool.
  • J2EE Object (EJB, JSP, Session) ? Relational
    (RDBMS) mapping tool
  • IDE Integrations (JBuilder, Forte, VAJ)
  • UML/Modeling Integrations via XMI (PowerDesigner,
    Rose, etc.)
  • Ease of use and performance
  • Ease of maintenance and high reusability
  • Sybase Resells CocoBase
Why is O/R Mapping used?
  • Before we examine the CocoBase product, well
    take a look at object/relational mapping concepts
    in a generic fashion. Enterprise O/R mapping is
    a particular set of requirements, and we must
    first understand those requirements to understand
    the value of CocoBase and how this fits with
    Power Designer and EA Server.
Why is Persistence needed?
  • In many enterprise level applications, there is a
    need for permanently storing of information
    related to a given business situation.
  • An Internet purchasing transaction is a good
    example of such a situation
  • New customers will log onto a website
  • Register their name, address, telephone number,
    credit card number and other vital information
    place orders.
  • This information is likely to be saved or
    persisted to a database through some
    data-mapping layer. This is often directly coded
    in the application through JDBC/SQL embedded
    within the application.
Where CocoBase Fits
Mapping for the Object to Relational World
  • Map from the Object World to Relational
  • Persisting an object from the object world adds
    one or more rows to tables in the relational
    world (db)
  • Map from Relational World to Object World
  • Performing a database search in Relational world,
    finds a number of rows. These rows of data are
    used to create instances of an object in the
    Object world.
  • Manage Relationships between objects
  • This is often called Lifecycle or Object Model
Where CocoBase Fits
  • THOUGHT Incs focus is on Java, and includes
    special integrations for Enterprise JavaBeans
    (EJBs), as well as an out of the box Session Bean
    ported to EAServer.
  • CocoBase can also provide standalone or direct
    object persistence of standard java classes with
    Session beans, JSPs, Applets or Applications.
  • CocoBase maps can be created from UML/XMI and be
    reused by different java code across multiple
    applications and programming models, reducing new
    development efforts.
EJB Transactions and the Data
  • EJB is a specification, based on the Java
    programming language, for developing enterprise
    level applications and among its many benefits
    are built-in transaction and distributed
    components capabilities.
  • For transaction management, this means that if a
    fault occurs while a transaction (such as a
    banking account update) is in progress, the
    entire transaction will be rolled back to a known
    valid state.
  • CocoBase integrates with and relies on the
    Transaction support of EA Server to manage
    coordinate transactions.
EJB Transactions and the Data
  • For distributed component management, an EJB
    application can communicate with both remote
    clients and databases.
  • This means that a merchant business running an
    EJB server in Argentina can have a database
    server running in Finland and a client
    application serving a customer base running in
  • While this scenario may currently be unlikely for
    every company, it demonstrates the power and
    potential of EJB and the Java programming
EJB Transactions and the Data
  • Because the EJB architectural specifications are
    maintained by Sun Microsystems Java Division.
    Both EJB and Java are supported by many major
  • BEA
  • Sun One AS
  • IBM
  • Sybase, etc.
  • and is used by an even larger set of
  • EJB has gained huge momentum in the enterprise
    development arena with IT. 55 of all Corporate
    Development will be in Java in 2002
Types of EJBs
  • Now, lets look at how EJBs actually work on the
  • There are two general types of persistent EJBs
    referred to as either Session Beans or Entity
    Beans (BMP and CMP).
  • The main difference between them is that Session
    Beans generally represent a process and are used
    to manage that process, and Entity Beans
    represent specific persistable, database-oriented
    entities (conceptually - a row of data).
  • Session beans however can directly access
    persistent data using the CocoBase generic
    session beans included with the distribution for
    Distributed Transparent Persistence and generally
    higher performance persistence than Entity Beans
    can provide.
How the Components Interact an example in action
  • A shopping cart application used for an online
    store may then have a ShoppingCart session bean
    managing the Customer and Order entity beans.
  • The Customer entity bean represents a customer
    and the Order entity bean represents that
    customers order.
  • THOUGHT Inc. ships a complex shopping cart
    example that demonstrates EJB, Session, and JSP
    with EA Server.
  • THOUGHT Inc. also ships an integrated Session
    Bean for EA Server Server that implements complex
    distributed Transparent persistence with lazy
    loading for EA Server.
How the Components Interact
How the Components Interact
How the Components Interact
  • Here, we get to another distinction between
    session beans and entity beans in that while both
    session and entity beans can retrieve data from a
    database, traditionally only entity beans persist
    data to the database. Note that this is not a
    restriction as much as a common practice.
  • Session beans can directly access persistent
    data, and with an O/R mapping tool actually
    provide an easier programming model and better
    complex data persistence than Entity Beans
How the Components Interact
  • Therefore, while the ShoppingCart session bean
    manages the current shopping cart session by
    delegating specific tasks to the subordinate
    entity beans - Order and Customer, only the Order
    and Customer entity beans actually persist the
    data resulting from the current shopping session.
  • This data may include, for example, the quantity
    and types of items ordered and whether or not the
    customer has a new address.
Data into the Component
  • Now, lets look at how the data gets into the
    database in more detail.
  • An EJB executing a purchasing transaction will
    eventually need to make a permanent record of the
    results if the company hosting the transaction is
    to be profitable.
  • In order to make a permanent record of the
    transaction, the EJB will have to write its
    data to some database.
EJB Components
  • In the following slide, data attributes from a
    simplified EJB component representing a customer
    account are written to a set of database tables
    (real world EJBs actually have several parts
    comprising the component).
EJB Components
EJB Components
  • Each table contains a set of columns, each
    corresponding to at 1 one attribute in the
  • The EJB for example, contains a String attribute
    resAddress, which corresponds to a VARCHAR
    attribute res_address in the Customer table.
  • In order to make this match, some mapping scheme
    must exist to pair the object attribute with the
    table entry.
Using the Database and the Map
  • Writing or persisting data to a database through
    a map creates a permanent copy of the result set
    of some transaction or process that has occurred
    in the application.
  • This data can then be retrieved for further
    processing or for future reference at some later
Starting with UML
  • CocoBase can start with the database tables, java
    classes or a UML tool like Power Designer.
  • The created model is exported as an XMI file
    using the UML/XMI exporters that ship with UML
  • The XMI file is imported into CocoBase.
  • This creates the maps navigation and
    inheritance model representations.
  • Database tables can be created as well if the
    customer wants.
Dynamic Mapping Using CocoBase
  • Dynamic Mapping Using CocoBase
  • Dynamic mapping means the object (ie the map) can
    be changed on the fly without recompile or
    regeneration of code.
  • With Dynamic Mapping, a map can be shared across
    many object models
  • Servlet , JSP, Session, CORBA or RMI client,
    applet, EJB object, or Java Class
  • these can all share the same map which is
    dynamically loaded from the CocoBase repository
    at runtime.
  • They can even share the same mapping definition
    and even the same object cache simultaneously!
Dynamic Mapping Using CocoBase
  • As an example, a companys IT section could write
    separate EJB components for the Sales and
    Accounting divisions and these two EJBs could
    share the same database map because they access
    the same data, even though the business rules
    associated with each EJB are entirely different.
  • The Sales organization could then report their
    quarterly sales figures to the database through
    their EJB application component.
  • These figures could then be retrieved by the
    Accounting division using their EJB application
    component, and used to publish the companys
    quarterly earnings.
Dynamic Mapping Using CocoBase
Dynamic Mapping Using CocoBase
  • The CocoBase toolset (CocoAdmin) can also
    generate the basic, non-proprietary Java code
    elements for the object model for the developer
    all in standard java form.
  • If the developer is creating an EJB, all of the
    EJB components can be generated as source code
    using CocoAdmin, command line tools or API.
  • This includes the Home and Remote interfaces and
    the Primary Key and Bean implementation classes.
Dynamic Mapping Using CocoBase
  • If the developer wants to
  • Performance tune or port an application
  • Optimize or change a database table structure
    (e.g. such that data is retrieved from a join of
    tables instead of just a single table)
  • Or redo the relationships in Power Designer and
    implement in CocoBase
  • the CocoBase mapping structure will allow
    changing a single mapping definition that can
    ripple through the entire enterprise and multiple
    applications in seconds.
Dynamic Mapping Using CocoBase
  • That change will be reflected across all the
    objects which use that map.
Dynamic Mapping Using CocoBase
  • This becomes a huge benefit in real enterprise
    application development where many objects will
    share a common mapping definition, as opposed to
    a quick prototype where a given mapping
    definition will correspond to a single or a few
    object definitions.
  • The ODMG (Object Data Management Group)/JDO and
    built-in CMP models and the embedded SQL
    (traditional BMP) model tend to break down in the
    Internet and enterprise space because they are
    too rigidly coded, too tightly bound, too
    inflexible, and they dont offer any way to
    enhance the functionality of the application or
    of the mapping behavior without significant
Dynamic Mapping Using CocoBase
Dynamic Mapping Using CocoBase
  • Another advantage of the dynamic model is that it
    allows for easy implementation of custom caching,
    custom routing, and other custom behaviors such
    as calling stored procedures or audit operations
    on the fly!
  • For example, if an example application was
    written against an RDBMS system and the developer
    finds that for their particular application that
    their version of the RDMBS and their platform
    doesnt perform fast enough, they can drop an
    in-memory cache database system into their
    applications on the fly, without changing any of
    the object definitions NO RE-CODING!
Dynamic Mapping Using CocoBase
CocoBase Plug-In
  • That plug-in will divert a query to the cache
    first, then use the map against the database if
    the data is not found in the cache.
  • Furthermore, CocoBase allows this type of caching
    to be supported across distributed object models
    and different server vendors.
CocoBase Plug-In
  • With the CocoBase plug-in system the developer is
    leveraging the mapping functionality, and
    enhancing it with this additional capability
    and without having to change the application
    logic or object model.
  • The mapping layer sits between the application
    and the database and is dynamic. Therefore it
    allows the developer to dynamically insert new
    behaviors through the callback plugin system.
JDBC Specific Code
  • If the developer was implementing an application
    using the JDBC driver model where database
    specific code is embedded directly in their
    object, they would have to manually add or change
    every driver hook in every object to take
    advantage of a newly available data caching
  • They would then have to re-compile and re-deploy
    every object that requires this new
  • CocoBase allows database and SQL specific calls
    to be inserted in the map and picked up at
Produce J2EE and J2SE Quickly
  • Using a dynamic model, the developer can also
    produce an application that is faster, more
    scalable and more extensible than a static model
  • Most people think that a static model, because
    theres no mapping layer, will perform more
    efficiently than our dynamic model but the
    reality is that Dynamic Mapping is usually as
    fast or faster than hand coded applications
    because of the optimizations which can be
    performed at runtime.
Dynamic Mapping Improves Performance
  • CocoBases mapping layer is so highly optimized
    and the enhancements that we have implemented are
    so sophisticated that applications written using
    the CocoBase mapping layer tend to run faster
    than hand written applications with a manually
    implemented, static database mapping system.
  • In some cases, up to 4000 (Yes! 40X) faster!
  • This is with plug-in caching enabled.
  • System performance gain without caching is up to
    400 over hand written applications.
CocoBase is Transparent
  • All of these benefits are achieved without
    requiring object inheritance from some special
    class or implementing some proprietary interface.
  • CocoBase Enterprise provides the most widely
    accepted standard in the industry for O/R mapping
    without requiring custom or proprietary changes
    to Java Classes.
CocoBase is Transparent
  • If this technology is coupled with database
    gateways and or the CocoBase plug-in extensions,
    the developer can even update data in multiple
    databases simultaneously from a single bean!
  • This is just one example of the flexibility
    afforded the developer or user using CocoBase and
    its runtime extensions.
  • This kind of enhancement would be prohibitively
    expensive to implement using the other mapping
The Cost of CocoBase to hand coded BMP and CMP
The Cost of CocoBase to hand coded BMP and CMP
The Cost of CocoBase to hand coded BMP and CMP
CocoBase Functionality
  • Dynamically Maps to all JDBC compliant databases
  • Create, Edit and Delete Maps
  • Single or many tables per map supported
  • Supports Stored Procedures even for EJBs
  • Automatic extensible Java code generation
  • Export Map repository as XML for runtime or
  • Import existing Java classes to create table and
  • Generate maps and beans from existing tables
  • User can customize CocoBase via properties files
  • Separate and powerful navigation to manage
    enterprise graphs of objects locally or
CocoBase Functionality
  • Automatic code generation
  • Code generated is based on editable templates
  • Templates defined by CocoBase (THOUGHT Inc.) and
    by users and or partners
  • Templates provided with the system for
  • Default Java Object
  • Transparent Persistence
  • EJB file set of CMP/BMP Entity Beans, Session
    Beans and JSPs for EA Server and other app server
CocoBase Functionality
  • Import Java Classes
  • Creates new database tables reflecting attributes
  • Generation of maps is aided by Java reflection
  • Relationships are somewhat auto-detected and
    auto-mapped to relational tables with current
    release, but UML provides the better solution for
    this task.
  • Reflection can auto detect public attributes or
    private attributes with public get/set methods
  • Supports primitive, but Object types
    typically required for null column support
How CocoBase Works
  • CocoBase Mapping is based on a repository
  • Map from object attributes to columns in many
    different tables supported
  • RDB or XML Repository (The map tables for
  • Objects are dynamically bound to the DB with Map
  • Mappings can be changed without having to
    recompile code or re-deploy beans
How CocoBase Works
  • Admin Tool is used for
  • Defining and editing mapping information
  • Generating EJBs or java classes related to a
    given map
  • Generating SQL-Scripts to create a table based on
    a given bean or Java Class(import)
  • Generating XML - Repositories for runtime
  • Can also do admin from command line or API
  • Small Overhead for Runtime
  • / - 5 performance hit over hand coded JDBC.
  • Usually a 30 gain or more in EJB application
    performance over hand coded JDBC
Application Servers and CocoBase
  • CocoBase uses the JDBC Connection Pool from
    application server
  • CocoBase doesnt commit any Transactions in EA
  • Transaction handling is done by the App Server
    container entirely
  • CocoBase can generate EJB (CMP BMP) Entity
    Beans, Session Beans, and JSPs from a Map
  • Everything that CocoBase generates is template
    based and therefore customizable
  • Relationships supported with EJB through Map one
    to one, one to many, many to many, bean to bean,
    bean to non-bean
Application Servers and CocoBase
  • CocoBase generates the following for EJB Entity
  • Remote Interface, Home Interface, Bean
    Implementation, PK Class Implementation, and
  • Properties file for environment info (JDBC
  • Manifest file
  • Make file, batch shell to compile, to process
    the descriptor and to jar all the necessary
    elements into the jar file for the deployment
    into App Server.
  • CMP or BMP Bean with XML descriptor ready to
  • Do not have to (re) generate all the files when
    map changes occur.
Application Servers and CocoBase
  • CocoBase CMP Installer for BMP based CMP
  • Generate CMP with CocoBase or use Third Party
  • Once the generic CMP bean is generated from the
    template or from 3rd party tools, use the CMP
  • Read in the XML descriptor from CocoBase Bean or
    put in information by hand for the database and
    pick the Application server
  • CMP Installer checks the bean and subclasses it
  • Bean is tied to a map
  • Finders are created
  • Generate the code, check it over and deploy when
  • Pluggable CMP support available with Dependent
    Objects for almost 30 different server/versions.
Optimizations Used
  • Caching Maps the first time they are accessed
  • A configuration file defines which maps to cache
  • When using a XML-repository maps in XML file are
    always cached
  • Fetch caching of Result Sets
  • ejbFinder ethos return an Enumeration of primary
  • CocoBase caches the result set for later ejbLoad
  • Next time an ejbLoad invokes a select, CocoBase
    gets the data from the cache not from the RDB
  • Fetch caching can be turned on or off through
Optimizations Used
  • Methods to get and set the state of the bean
  • Fast access to the state of the Object through
    state serialization methods
  • Objects by Value transferred to/from client more
  • Modified flag
  • Update in ejbStore only if necessary by detecting
    bean changes
  • Set methods auto-generated to set modified flag
  • State transfer methods automatically use set/get
    methods for proper integration with Modified flag
  • Dependent Objects supported for coarse grained
    entity beans
  • One to many relationships of dependent objects
  • Low Overhead
Recap of Process
  • Model the objects with Power Designer
  • Export the Model as XMI
  • Import the XMI into the Dynamic Mapping Layer of
  • Create Database tables if desired
  • Edit the Maps
  • Generate the components for Sybase EA Server and
    run CocoBase CMP Installer if necessary.
  • Deploy functioning app

Q and A
  • Question and Answers
Developing with CocoBase
  • Business Benefits of CocoBase

Business Benefits of CocoBase
  • O/R Mapping Optimized for EJB
  • For any database access development with EJB,
    CocoBase Enterprise O/R is far and above the
    leading tool that delivers successful enterprise
    level applications while saving up to millions of
    dollars in development costs.
Business Benefits of CocoBase
  • O/R Mapping Optimized for EJB
  • CocoBase Enterprise O/R has been highly optimized
    for EJB in order to meet the enterprise-level
    needs for
  • Optimizing Performance
  • Optimizing Cost savings
  • Optimizing Scalability
  • Optimizing Portability
  • Optimizing Reuse and Maintenance process
Business Benefits of CocoBase
  • Optimizes Performance
  • CocoBase Enterprise O/R optimizes system
    performance because it
  • Uses a local object mechanism which greatly
    reduces the number of transactions between an
    application and a network
  • Uses a data caching mechanism which greatly
    reduces the number of transactions between an
    application and a database
  • Provides an open architecture which allows easy
    integration of third party optimization tools
Business Benefits of CocoBase
  • Optimizes Performance
  • CocoBase Enterprise O/R, with no optimization,
    impacts a system with a /- 5 overhead as the
    database access layer.
  • In contrast, other O/R mapping tools impact a
    system with a 25-30 overhead as the database
    access layer.
Business Benefits of CocoBase
  • Optimizes Performance
  • With the standard optimizations, CocoBase
    Enterprise O/R increases the speed of EJB
    applications by 300-500 over manually coded
  • With optional plug-in tools, CocoBase Enterprise
    O/R can improve performance for database
    intensive EJB applications by 4000 or more
    depending on the platform and database used.
Business Benefits of CocoBase
  • Optimizes Cost Savings
  • Decreases the cost of database access
    development, deployment, and maintenance by up to
  • Generates the entire CMP BMP Entity bean as
    well as JSP and Session Beans for you beyond Java
Business Benefits of CocoBase
  • Optimizes Cost Savings
  • CocoBase Enterprise O/R automatically generates
    all of the CMP and BMP Entity beans for the
  • As the only O/R tool to do so, the time savings
    and resulting cost savings is extraordinary.
  • The average Bean Managed Entity bean takes up to
    forty (40) man hours to manually create.
  • With CocoBase Enterprise O/R, this time is
    reduced to about 10 (ten) to twenty (20) minutes.
Business Benefits of CocoBase
  • Optimizes Cost Savings
  • With the average e-commerce application requiring
    over a hundred Entity beans, the cost saving can
    easily be over a million (1,000,000) for a
  • For ROI see http//
Business Benefits of CocoBase
  • Optimizes Cost Savings
  • As the market leader for O/R mapping and the only
    tool integrated with all of the leading EJB
    Servers, CocoBase Enterprise O/R provides a truly
    portable and complete development platform for
    database access.
Business Benefits of CocoBase
  • Optimizes Cost Savings
  • Using CocoBase Enterprise O/R, one company
    realized a faster time to market and a labor
    savings of approximately 3 million for a single
Business Benefits of CocoBase
  • Optimizes Scalability
  • Uses an array of sophisticated resource
    management design patterns which drastically
    reduce the amount of network and database
  • Fully supports distributed applications servers
    enabling the dynamic addition of resources in
Business Benefits of CocoBase
  • Optimizes Scalability
  • A system with a fixed set of resources utilizing
    the built-in CocoBase Enterprise O/R resource
    management design patterns which will support a
    larger number of simultaneous users and can
    readily be expanded as your enterprise
    requirements increase.
Business Benefits of CocoBase
  • Optimizes Portability
  • The Entity beans created by CocoBase Enterprise
    O/R are portable for use in any EJB server by
    generating the descriptor and make files specific
    to a particular EJB server.
  • CocoBase Enterprise O/R supports Sybase EA
    Server, BEA Weblogic, Borland, HP, IBM Websphere,
    JBoss, Oracle, Orion, Sun One AS and others.
Business Benefits of CocoBase
  • Optimizes Portability
  • The CMP and BMP Entity beans that CocoBase
    Enterprise O/R generates are a standard
    implementation of the EJB 1.0, 1.1, 2.0 and J2EE
  • By simply adding the additional descriptor and
    make files specific to the EJB server, Entity
    beans can be quickly loaded into the server of
Business Benefits of CocoBase
  • Optimizes Portability
  • You do not need to have a server in place to
    begin developing applications. CocoBase has
    provided Java Classes for the last 6 years
  • If your company is still evaluating EJB server
    vendors, you can begin development of CocoBase
    Enterprise O/R and choose your EJB server when
    you are ready.
  • Developed by Thought Inc., the market leader in
    object to relational (O/R) mapping technology,
    CocoBase Enterprise O/R optimized for EJB
    provides customers with a unique and patented
    technology that results in a multitude of
    business advantages over other common O/R
    database mapping methods and tools.
  • CocoBase Enterprise O/R provides significant
    business advantages over other O/R mapping
    methods and products primarily because of dynamic
    mapping, dynamic navigation, dynamic query
    system, automatic code generation, portability
    across standard EJB servers, the ability to reuse
    code, extremely high performance because of
    optimization for JAVA and J2EE and low cost of
  • CocoBase Enterprise O/R is the most mature O/R
    tool available and fully supports JAVA as well as
    the EJB 1.0, 1.1, 2.0 and J2EE specifications.
  • Additionally, CocoBase Enterprise O/R
  • Decreases cost of application development,
    deployment and maintenance by up to 85.
  • Increases speed of EJB applications by up to
    400. Allows changes to both the database and the
    resulting maps that do not require editing and
    recompile of the application.
  • This independence between the application
    components and the database greatly simplifies
    the tasks related to maintaining an application
    over the long term.
  • CocoBase Enterprise O/R has broad industry
    support and acceptance as it is integrated with
    over 10 major EJB servers.
  • Supports highly scalable applications and reduces
    overhead with fetching of objects and integration
    with EJB distributed transactions.
  • Sybase resells CocoBase
  • Provides an easy-to-use template based Entity
    bean code generator dramatically reduces manual
    coding and debugging.
  • A Swing based GUI administration tool quickly
    steps users through the default process of
    mapping objects to relational database tables.
  • Eliminates vendor dependence by integrating with
    almost all EJB servers and relational databases,
    modeling tools, and Java Development Environments
Shopping Cart Example
  • Features
  • Utilizes BMP and CMP Entity Beans as well as
    Stateful and Stateless Session Beans
  • Organization by Categories Classical Online
    Shopping Cart Layout
  • Scalability - No limitation on number of
    categories, subcategories, and items. Scalable
    across multiple application servers and JVMs
Shopping Cart Example
  • Features
  • Customizable - Implementation is easily adapted
    to most e-commerce applications
  • Security - Uses Web Servers built in SSL
  • Customer Ease of Use - Intuitive Familiar
    Shopping Cart Interface
  • Merchant Ease of Use - Basic Knowledge of SQL
    needed to get up and running for the EJB server.
    More in-depth knowledge of Java, EJB JSP needed
    for EJB business logic manipulation.
Shopping Cart Example
  • Features
  • 100 Java Implementation
  • Works with Netscape and Internet Explorer.
  • Automatically e-mails order verification to
  • Automatically generates merchant side XML order
  • Automatically checks customer order quantity
    against inventory
  • Uses JSP technology to produce dynamic web
  • Uses JDBC standard and CocoBase for database
Shopping Cart Example
  • Requirements
  • CocoBase Enterprise O/R to provide EJB and
    Database Server portability
  • EBJ Server to run the provided or extended EJB
  • EJB Server to provide persistence capabilities
    for transactions
  • EJB Server to run JSPs
  • Netscape or Internet Explorer to view JSP/HTML
Shopping Cart Example
  • Compatibility
  • Shopping Cart will work with any JDBC enabled
    database supported by CocoBase Enterprise O/R.
  • Shopping Cart EJB Classes can be generated for
    any EJB Server supported by CocoBase
Thank You