Submit Feedback

Architecture

The Liferay DXP/Portal architecture has three parts:

Core: Bootstraps DXP and its frameworks. The Core provides a runtime environment for managing services, UI components, and customizations.
Services: Expose DXP functionality and custom functionality via Java APIs and web APIs.
UI: The optional web application UI for adding portals, sites, pages, widgets, and content.

You can use the UI and services together or focus solely on using services via REST APIs or GraphQL APIs.

Sites contain content and widgets. DXP can also be used headless---without the UI.

The architecture satisfies these requirements:

Supports using common development technologies
Leverages development standards
Facilitates swapping components
Starts fast and performs well
Its runtime is easy to configure and inspect

The Core supports UI and service deployments and orchestrates wiring them together.

Core

DXP is a web application that runs on your application server. The Core bootstraps the application and its frameworks.

There are frameworks for these things and more:

Adaptive Media
Application Configuration
Application Security
Assets
Cache
Data Scopes
Dependency Injection
Expando/Custom Attributes
File Management
Localization
Logging
Message Bus
Scheduler
Search
Segmentation and Personalization
Service Builder
Testing
Upgrade Processes
Virus Protection
Workflow

The Core provides the component runtime environment for the frameworks, services, and UI. Here are some component examples:

The following figure shows these component types in the runtime environment.

The Core provides a runtime environment for components, such as the ones here. New component implementations can extend or replace existing implementations dynamically.

The runtime environment supports adding, replacing, and customizing components on-the-fly. This makes the following scenarios possible:

Replacement: If the ServiceC Impl 2 component has a higher ranking than existing component ServiceC Impl 1, ServiceC Impl 2 is used.

Customization: The PortletA Filter intercepts and modifies requests to and responses from PortletA, affecting the content PortletA displays.

Component WAR and module JAR projects install as OSGi bundles (modules). Liferay’s OSGi framework defines the module life cycle, enforces dependencies, defines the class loading structure, and provides an API and CLI (Felix Gogo Shell) for managing modules and components. The Core is configured via Portal Properties files and System Settings.

The service components provide business functionality.

Services

Business logic is implemented in services deployed to the component runtime environment. Built-in Core services and framework services operate on models such as Users, Roles, Web Content, Documents and Media, and more. You can introduce new models and functionality through custom services. Service components can access each other via dependency injection.

Frontend applications invoke the services to do work. You can deploy Java-based applications that call services directly using the Java APIs. Any web-based (Java and non-Java) application, whether deployed on DXP or not, can use the web APIs, including REST APIs that conform to the OpenAPI standard, GraphQL APIs, and plain web/REST services. The following figure shows applications and external clients invoking Liferay services.

Local and remote applications can invoke services via REST web APIs. Java-based portlets can also invoke services via Java APIs.

Liferay services are built using Service Builder and made REST-ful using REST Builder. The services are easy to override and extend too.

The web-based UI makes content and service functionality available in browsers.

UI

The UI helps people do work, collaborate, and enjoy content. Here’s what the UI consists of:

DXP application: The web application for managing Portals, Sites, Users, Pages, Widgets, and more.
Applications: Widgets that provide a user interface for services already deployed.
Themes: Plugins for styling Sites with a unique look and feel.

The UI architecture articles dig deeper into developing and customizing UI components.

As you can see, the architecture supports developing services, UI components, and customizations. The architecture section covers Core, service, and UI topics. Next, dive into the Core to learn class loading, modularity, and more. But you can jump ahead to any service or UI architecture topics, if you like. Enjoy exploring the architecture!