OpenSubsystems

Open Core is a middleware abstraction layer providing foundation for rapid development and smooth integration of open subsystems. It's goal is to help developers build applications faster and easier by providing simple-to-follow but flexible architecture suitable as much for high-performance enterprise applications as well as for quick projects on a tight schedule.

Fast, easy and flexible development

• Data model, persistence, business logic, web user interface and desktop application (thick client) framework usable as simple Java classes (POJOs) or within J2EE application server. Quick Start gives you a short overview of various components of the framework. Tutorial will walk you through development of an entire application using Open Core.
• Ant based build process allowing you to build your application and automatically generate jar, war and ear files.
• Ability to deploy the same code either as a simple Java application built using POJOs or as a J2EE enterprise application.
• J2EE application server support for JBoss, JOnAS, WebLogic, WebSphere
• Ability to easily add support for new J2EE application servers.

Persistence layer

• Default persistence layer implementation provided using pure JDBC for high performance, low overhead and easy portability. There is nothing in between the application and the database other than a JDBC driver.
• Developer can easily replace or supplement the default implementation with it's own persistence layer implementation technology, such as Hibernate, JDO, file persistence, etc.
• Even the default pure JDBC implementation requires only a few lines of code utilizing provided database operation objects, such as read, read multiple, update, batch create, batch update.
• Persistence layer architecture and implementation ensures optimistic locking preventing concurrent data modification, unique data id generation and timestamp maintenance directly by a database.

Database support

• Database schema definition, maintenance and versioning allowing application to create and modify tables, views, indexes and other database objects in a controlled manner.
• Ability to define dependencies between database objects to ensure their creation, upgrade and initialization in a correct order.
• Ability to automatically create database users required by application for its database connections and connection pools.
• Database support for DB2, HSQLDB, MaxDB, MS SQL Server, MySQL, Oracle, PostgreSQL, SAP DB, Sybase ASE
• Ability to easily add support for new databases.

Connections and transactions

• Database connectivity, connection pooling and transaction management available in a consistent manner regardless of the deployment strategy (POJO or J2EE).
• Custom in-JVM transaction manager provides high-performance low overhead solution allowing to still utilize JTA transactions in scenarios where full distributed capabilities are not required. The code can be without change deployed with full featured transaction manager in a distributed environment when needed.
• Connection pool support for Commons-DBCP, C3P0, Proxool, XAPool and J2EE datasources
• Transaction manager support for JOTM, J2EE transaction managers and custom in-JVM transaction manager
• Ability to easily add support for a new connection pools or a new transaction managers.

Business logic layer

• Ability to develop and deploy business logic as simple Java classes (POJOs) or as EJBs without change in the code.
• Framework and patterns for data access and modification providing most of the code performing this functionality for you.

User interface layer

• Web user interface framework providing session tracking and authentication support, built-in support for SSL and distributed access.
• Default web user interface implementation provided using Tiles template engine. Multiple reusable web page and application layouts are included.
• Ability to construct web user interface from multiple separate application modules automatically integrated together.
• Entire configuration and integration done using standard web.xml file, no need to learn and maintain another proprietary file format.
• Desktop application (Thick client) framework providing ability to easily construct desktop applications from separate application modules.
• Default application framework implementation provided using SWT allowing deployment of desktop applications in various environments (Windows, Mac, Linux, etc.) while still using the native controls and look&feel.
• Developer can easily replace or supplement the default implementation with it's own user interface technology, such as Swing, AWT, QT, GTK, etc.

Utilities

• Utilities for context propagation, asynchronous executions, encryption, transactional file manipulation, and much, much more...

Quality

• Over 167 automated JUnit and visual web tests.
• All source code meticulously code reviewed.