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