See Section 4.1.1, “Application Tiers and Blocks”.

Application properties are named data values of various types that define different aspects of application configuration or functions. See Section 4.2.8, “Application Properties ”.

See Section 4.1.1, “Application Tiers and Blocks”.

In the context of this manual, an artifact is a file (usually a JAR or ZIP file) that contains executable code or other code obtained as a result of building a project. An artifact has a name and a version number defined according to specific rules and can be stored in the artifact repository.

A server that stores  artifacts  in a specific structure. The artifacts that the project depends on are loaded from the repository when that project is built.

Containers control lifecycle and configuration of application objects. This is a base component of the dependency injection mechanism also known as Inversion of Control.

CUBA platform uses the Spring Framework container. For extra information, please refer to the section called “Further Reading”.

A relational database.

See Section 4.5.3, “Datasources”.

Also known as Inversion of Control (IoC) principle. A mechanism for retrieving links to the objects being used, which assumes that an object should only declare which objects it depends on, while the container creates all the necessary objects and injects them in the dependent object.

See http://en.wikipedia.org/wiki/Dependency_injection.

Loading data from subclasses and related objects together with the requested entity.

Main element of the data model, see Section 4.2.1, “Data Model”.

A screen containing a table with a list of entities and buttons to create, edit and delete entities.

A middle tier component for working with persistent  entities.

See Section 4.4.4.1, “EntityManager”.

An element of aspect-oriented programming that allows changing or extending object method invocations.

See http://en.wikipedia.org/wiki/Interceptor_pattern.

Simplified Java Enterprise Edition profile created for web applications that do not use technologies like EJB, JTA and others.

Java Management Extensions − a technology that provides tools to manage applications, system objects and devices. Defines the standard for JMX-components.

Additional details are available at: http://www.oracle.com/technetwork/java/javase/tech/javamanagement-140525.html.

See also Section 6.4, “Using JMX Tools”.

Java Persistence API – a standard specification of the object-relational mapping technology (ORM). CUBA platform uses  Apache OpenJPA framework that implements this specification.

Platform independent object-oriented query language, defined as a part of the JPA specification.

Additional details are available at: http://openjpa.apache.org/builds/2.2.0/apache-openjpa/docs/jpa_langref.html.

See Section 4.4.4.3, “Lazy Loading”.

An entity attribute that is not a reference or a collection of references to other entities. Values of all local entity attributes are typically stored in one table (with the exception of certain entity inheritance strategies).

See Section 4.2.9.1, “Message Packs”.

 Components that contain application business logic.

See Section 4.2.4, “Managed Beans”.

See Section 4.2.9.2, “Main Message Pack”.

Managed Beans that have a JMX-interface. Typically, such beans have an internal state (e.g. cache, configuration data or statistics) that needs to be accessible through JMX.

Middle tier –  the application tier  that contains the business logic, works with the database and provides a common interface for higher client tier of an application.

Optimistic locking – an approach to managing access to shared data by different users that assumes a very low probability of simultaneous access to the same entity instance. With this approach, locking itself is not applied, instead the system checks if a newer version of the data is available in the database at the moment when the changes are being saved. If so, an exception is thrown and the user must reload the entity instance.

See also http://en.wikipedia.org/wiki/Optimistic_concurrency_control.

Object-Relational Mapping – a technology that links tables in a relational database to objects of a programming language.

See Section 4.4.4, “ORM Layer”.

A set of entity instances loaded from the database or just created. Persistent context serves as data cache within the current transaction. When transaction is committed, all persistent context entity changes are saved to a database.

See Section 4.4.4.1, “EntityManager”.

Plain Old Java Object – a Java-object that has not been inherited from any specific class and that does not implement any service interfaces except the ones required for business logic.

A Java class containing screen initialization and event handling logic. Works in conjunction with screen’s XML-descriptor.

See Section 4.5.1.3, “Screen Controller”.

Middleware services provide the business interface for client calls and form the Middleware boundary. Services can encapsulate the business logic or delegate the execution to Managed Beans.

See Section 4.4.1, “Services”.

See Section 4.2.1.4, “Soft Deletion”.

User Interface.

See Section 4.2.3, “Views”

A local file system directory containing the application project. Contains source code, build.gradle, settings.gradle build scripts and IDE project files.

See Chapter 5, Application Development.

An XML file containing layout of visual components and datasources for a screen.

See Section 4.5.1.2, “XML-Descriptor”.