|JUVE Java Universal Vehicle for Enterprises|
JUVE is an application design framework created for flexible and fast development of performant and scalable multi-tier applications. JUVE is originated in JAVA environment, but its implementation does not rely on any JAVA specific solutions and currently there are also implementations in another programming languages available. The fast development path of architecture patterns like EJB makes it reasonable to ask, whether the application development based on one architecture is a reliable investment for the future. XML based application server solutions are at the corner, practical scalability and performance problems related to EJB architecture are commonwealth of so many projects. JAVA as high level programming language with runtime code interpreted by a virtual machine, requires compromized, but very effective architectures and implementation of the application code.
JUVE as application framework and architecture provides a simple and solid solution for broad range of application development cases: from simple single tier applications to multi-tier systems. JUVE is primarly implemented in JAVA, but it is highly portable, does not stick to JAVA specifics, and its focus is more to encourage object oriented methods in development process.
JUVE as an architecture concept is implemented in JAVA, C#/.NET, C++, Delphi. JUVE is object-oriented and defines a few basic classes to be inherited by the application developer.
JUVE is based on and strongly supports the use of layering architecture pattern. The main layer of the application is the domain layer, containing the business objects. The domain layer is used symmetrically both on the client and the server. The basic data processing scenario ( loading business objects from the database, transferring them to the client, processing data on the client, transferring back the changes to the server and updating the changes in the database ) requires, that the business objects ( as single object, object list or object tree or graph ) will be transferred between client and server by using JUVE-specific, optimized serialization and communication. Symmetrical usage of domain layer means that the domain classes are used both on client and on server. This concept is contrary to proxy pattern-based access to the business objects, as used in popular application frameworks.
XML language is used by JUVE as standard communication method. For high optimization purposes, alternatively always a native serialization is available. By using XML the server application in JAVA can communicate with the C++ client.
The kernel code of JUVE provides mechanisms for
The database access layer in JUVE environment is developed completely by the application developer. JUVE provides some simple basic classes, specifying the interfaces and providing some basic functionality. But the main work is still done by the developer. Integration of other OO-RDBMS-mapping than JUVE SQL tools is possible, but not preferred. The JUVE Code Generator simplifies to some extend the process of development of the database access layer, but there is still a lot to develop. Reason: we believe, that the database access layer has to be highly optimized, therefore the usage of all available SQL optimization methods is absolutely vital. In JUVE environment there is no black box, the access layer developer can take advantage of comfortable JAVA/JDBC (or equivalents) debugging and use any means necessary to achieve the expected performance.
The communication concept of JUVE is highly portable, there are implementations based on socket-based server, EJB-based environment and JUVE's own highly scalable application server. Due to strong XML orientation, and WebServices/SOAP based developments, the future of JUVE-based applications is sure. JUVE does not use any metamodel technique, everything is clearly visible in application and framework code.
JUVE is quite simple and average developer with OO background can manage to develop applications based on JUVE very quickly.
Major parts / modules
JUVE consists of several modules:
JUVE XML is a basic framework providing high speed serialization of objects and its used for implementation of high speed communication between system parts.
JUVE XML in the basic version contains XML based high speed serialization. Additional packages of JUVE XML offer special native serialization, support for compressed and encrypted serialization, XML comparison utility, etc.
JUVE Basic contains basic classes for data processing. The major class tree starts with the class EntityState, defining state mechanism for management of data and object changes. The class BasicEntity follows with basic functionality for database based storage of data. The class StandardEntity extends its base classes by standard attributes, used in most relational database based systems.
The class Term is a base class for implementation and management of static data in the application. Static data change not often in the lifetime of the application and can be easily cached.
The class DatedEntity is a base class for date or timestamp related objects. The class PeriodEntity provides mechanisms for period handling in the application.
JUVE Basic contains also basic container classes, extending the well known standard libraries container classes by functionality required in client/server environment.
JUVE People contains definition and implementation of basic structures handling data of a person, a company, its post addresses, email addresses, phone and fax numbers, etc., etc.
JUVE People classes are easily extendable: you can create CRM / ERP / accounting solutions without starting from scratch.
JUVE Appli contains structures and funktionality required for implementation of more complex applications:
- user management, definition of commands within the system, permissions, user roles
- logging utilities, process management, definition of application, its resources and interfaces
- scheduler for task management
JUVE Resource Management Module manages the access to the system resources like database connections, Data Stores, File Stores, etc.
The resources are managed according to their nature and role in the system: the database sessions can be pooled by using the JDBC2 pooling or other mechanisms, the static data or data files can be cached in memory.
By applying this module the application can optimize and control usage of system resources.
JUVE Web Services is a basic library for implementation of client/server applications using Web Services interfaces and applying the SOA architecture pattern.
JUVE Web Service Provider is an interface wrapper, supporting the definition of application interfaces in a generic way and use of high level JUVE classes as interface parameter.
JUVE Client Framework is a comprehensive framework designed for implementation of the client part handling graphical user interface of the application. The architecture of JUVE Client Framework is based on modified MVC design pattern ( we call it MVC+ architecture pattern ). MVC+ decouples the cooperation of the view layer and the controller layer by using for communication between view layer and controller layer a basic abstract interfaces implementing the listener pattern. This approach ensures that the controller layer is by almost 100% reusable, even in case of complete change of the view layer ( eg. if application switch from JAVA SWING GUI library to SWT library ). By using the JUVE Web Client Framework even the implementation of a HTML user interface allows almost complete reuse of the previously developed controller layer !
The domain classes layer from the basic JUVE framework is used as model layer in context of the JUVE Client Framework.
JUVE Client Framework contains also helper classes support major GUI libraries on higher level ( JAVA SWING, JAVA SWT, C# Forms etc. ).
JUVE Web Client Framework is a framework extension of the JUVE Client Framework for implementation of HTML based frontends ( user interfaces ). JUVE Web Client Framework introduces a new technology: no JSP, no ASP, no struts, etc.
The generation of the HTML pages by the JUVE Web Client Framework is based on the template-filter-pattern:
- the HTML designer designs HTML page patterns and specifies data fields to be filled with application information with data tags ( eg. %%User%%FirstName%% )
- HTML filter class from JUVE Web Client Framework filters the HTML page pattern file ( cached in memory by the JUVE Resource Manager ) characterwise ( each character is processed only once ! ) and replaces "on the fly" the data tags by the current data values
The HTML page patterns contain no application code ( Java code, pseudo code etc. ), no debugging is necessary, and HTML design is decoupled from application programming. No special tools for simulteanous development, design and debugging are necessary, and highest performance is ensured.
New perspectives for application development and deployment
JUVE simplifies the application development process by providing a solid and simple basement for any multi-tier or even single tier application development. JUVE was used in development of both quite simple products, and complex systems. Due to high performance of JUVE based architectures, the project risks are minimized - although the rapid development is still feasible. Reuse of models and code is strongly encouraged-XML based domain data definitions is a by-product of application development and provide a solid base for future oriented developments. Scalability and performance of all layers reduces costs of hardware.
Juve Architecture Framework ( PowerPoint presentation in PDF )
Juve SQL Layer Framework ( PowerPoint presentation in PDF )
MVC+ Architecture Pattern ( PDF )