OpenSubsystems

Business Components for Java Applications

Subsystems

Open Core

Documentation
Download
How to Extend
Last modified

$Author: bastafidli $
$Date: 2007/03/24 08:35:37 $
$Revision: 1.28 $
$RCSfile: index.html,v $

Open Core

Open Core is a middleware abstraction layer allowing subsystems and applications to seamlessly run directly on top of Java Virtual Machine or inside of various J2EE application servers. This all without changing single line of code while providing the same level of services such as connection pooling and JTA/JTS transaction management across different environments. It enables consistent and efficient access to various databases taking advantage of native features of each database. It defines patterns for data model design, persistence tier, business logic and user interface interaction. See full list of features for more details.

Why to use it

The goal of Open Core is to help developers build applications faster and easier by providing more than just a code.

  • It includes simple-to-follow but flexible architecture suitable as much for high-performance enterprise applications as well as for quick projects on a tight schedule. It provides build process addressing all aspects of Java application development. And of course it provides lots of reusable code modules to deliver functionality faster and with higher quality thanks to many included automated unit tests. Read the summary of a tutorial discussing development or a real world application to see for yourself.
  • Open Core doesn't focuses only on a single area of Java application development. It equally addresses application data model, persistence layer, business logic and user interface for both web and desktop applications.
  • Open Core allows developers to avoid vendor lock-in and protect their investment in the technology. It works on Windows, Linux, Unix and Mac, supports all leading database management systems and J2EE application servers as well as all frequently used servlet containers. It allows choice of multiple connection pools and transaction managers as well as multiple ways how to deploy your applications. Its web user interface elements supports Internet Explorer, Mozilla, Firefox.
  • Open Core is compatible with various popular projects and software products and allows developers to replace the default implementation of any layer of the application with their technology of choice. It is easy to integrate any popular object-relational mapper or user interface framework.
  • Open Core is very easy to learn and requires only knowledge of Java, JDBC, Servlets and JSP.
  • Open Core is foundation of all subsystems delivered as part of OpenSubsystems project.

Who is it for

Open Core is tool for Java developers to implement their own subsystems or applications easier. When developing custom applications, developers provide application specific data model, business logic and presentation tier built using Open Core. Open Core provides most of the glue, which connects it together as well as with other subsystems delivered as part of the OpenSubsystems project.

When to use it

Developers should consider using Open Core whenever they have need for:

  • Writing high performance subsystems and applications for which there is a need to have control over each and every line of the executed code for troubleshooting and performance optimization. Patterns defined by Open Core organize the code into the most efficient execution path from the user or client interface to the persistence tier. Even though developers write every single line of code and nothing is generated, constrained or controlled in any fashion by any container, in few lines of code data can be efficiently processed, retrieved or stored in the persistence store.
  • Preventing J2EE application server vendor lock-in. Open Core acts as a middleware abstraction layer between the subsystems and the J2EE application server. It guarantees that the same level of services such as connection pooling or JTA/JTS transaction management is provided on each server and makes them accessible in the same fashion. Porting of application from one J2EE server to another is matter of minutes instead of days and weeks.
  • Running applications with just Java Runtime Environment without any J2EE application server while maintaining the same level of functionality. Open Core abstraction layer provides resource efficient implementation of many common services (such as connection pooling, JTA/JTS transaction control) that allow applications be deployed in resource contrained environments, such as embedded systems without requiring any heavy or expensive infrastructure.
  • Developing applications that have to support and integrate with various databases while still taking advantage of native features provided by each database. Open Core established patterns that cleanly separate database independent and database dependent code. It allows developers to write database access code optimized for each supported database while Open Core ensures that the database specific code will be called only when the specific database is used.
  • Deploying self contained application in an unmanaged environments when the application itself has to ensure correct initialization of the environment, such as creation of database tables, indexes, stored procedures, etc. Open Core tracks database state and ensures that your database initialization code is propertly executed when the database needs to be initialized (e.g. during first time installation) or upgraded (e.g. when new version of the application is released).

How to use it

To get an idea how you can use Open Core take a look at the Quick Start guide and the Tutorial.

Open Core is an infrastructure component used to develop Java applications and subsystems. You will need to download the binary distribution package core-bin-xxx.zip to take full advantage of its functionality. Include all jar files found in the lib folder on your classpath. You will be able to immediately use all classes documented in the JavaDoc API. The API can be found in the docs folder. You may also need libraries from the external\runtime folder on your classpath once you run your application. To speed up your development and configuration you may want to use some of the files included in the sources folder.

The supplied demonstration packages allow you to see various UI template layouts included with Open Core, static version of various Open Core pages and examples of Open Core custom JSP tags. It also allows to exercise Open Core backend logic using over 150 included JUnit test cases that can be executed directly from your browser. The demonstration distribution package core-app-xxx.zip contains ready-to-deploy web application core-app.war in the webapps folder. You can copy this file to the deployment folder of your server or use the management application supplied with your server to deploy the demonstration application. If you encounter error related to missing classes or class cast issues and you are using servlet container rather than a full J2EE server you may need to include files jts.jar and jta.jar found in the external folder into folder on your server designated for shared libraries. In Tomcat this is \common\lib folder and in Jetty \ext folder is suitable for this purpose.

Alternatively you can use core.war from the lib folder of the binary distribution package core-bin-xxx.zip or demonstration distribution package core-app-xxx.zip to exercise Open Core backend functionality using the JUnit tests and see examples of the Open Core web ui elements. You will also have to copy all libraries from the external/runtime folder to a location, where your server will find them and make them automatically available to the installed web applications.

Once deployed, you can access the tests using one of these URLs depending on the server you use, for example

Next: Features