Introduction to CRISP API

Spring Security OAuth Library Removed from CRISP in XM Version 15

The Spring Security OAuth project is deprecated, and the related library has been removed from CRISP as of version 15.0.0. Features provided by Spring Security OAuth, such as the OAuth2-based RestTemplate, are no longer available in CRISP from this version onward.

To implement OAuth2-based integrations, use Spring Security 5. Refer to the OAuth 2.0 Migration Guide for a recommended approach.

What is CRISP?

CRISP (Common Resource model Interface and Service Provider) is a module for integrating external APIs, such as API Gateways, into Bloomreach Content. CRISP provides a standardized way to connect, aggregate, and personalize content from external services.

By using CRISP as an integration backbone, you can simplify content aggregation and personalization in your application. CRISP improves transparency and reliability when connecting to external systems.

The project source code is available at https://github.com/bloomreach/brxm/tree/brxm-14.7.3/crisp.

Why Use CRISP?

When integrating external services (REST, web services, APIs, etc.) into an application, a common pattern is to use a shared invoker service. Each component on a page retrieves data through this shared service.

Diagram: This diagram shows a content delivery web application ("AS-IS") with internal components (AggregationValve, HstComponentInvoker, multiple HstComponents) all sending requests to a shared API Service Invoker, which connects to an external system. An Administrator configures the integration point.

Typical integration scenarios raise several architectural concerns:

• Performance / Efficiency: How do you ensure high performance and avoid duplicate requests from different components during a single page render? How do you implement caching for delivery tier performance?
• Security: How do you provide secure access and authentication (such as OAuth2) to backend services?
• Availability: How do you prevent backend service failures from affecting the availability of the main system?
• Configurability / Manageability: How do you update connection configurations (for example, to a Salesforce backend) at runtime without redeploying or restarting the server?
• Modifiability: How do you quickly update or improve integration service components?
• Cost-effectiveness: How do you achieve all these quality attributes without excessive cost or complexity?

CRISP addresses these architectural requirements by providing:

• A reusable and performant integration module designed for high-quality expectations.
• Faster and more cost-effective product and project delivery.
• Integration and aggregation of diverse data sources and services (API Gateway, ESB, REST, RSS, etc.) with minimal effort.
• The ability to aggregate external data and content without migrating it into a single repository.
• A toolkit for integrating with various backends (Commerce APIs, Salesforce, Eloqua, Marketo, etc.) to support personalization and content aggregation.

CRISP Vision

• Provide a lightweight, common resource API and service provider for enterprise data, content aggregation, and personalization.
• Offer a performant and reliable message exchange backbone, including built-in caching.
• Enable highly customizable and configurable message routing for different use cases.
• Serve as a core software asset for products and projects.

CRISP Features

• Generic external (REST) API service broker (ResourceServiceBroker).
• Generic resource object model (Resource) for easy access to resources and properties.
• Resource space routing configuration via Spring Framework bean configuration in the repository.
• Caching at both the ResourceServiceBroker and ResourceResolver levels, with configurable and customizable options.
• Usable in both content delivery and content authoring applications.
• HTTP invocations using Spring Framework RestTemplate for enhanced configurability and maintainability.
• Dynamic configuration management at runtime through repository configuration.
• Resource-level pagination.
• API support for implementing web-hooks (for example, to invalidate cache).

Planned future features include:

• Default support for XML-based resource representations (such as RSS feeds).
• Example ResourceResolver and Resource implementations for custom Java API calls on backends, beyond JSON/XML.
• Additional configuration examples for different backends. Contributions are welcome.

Architectural Views

Components and Connectors View

Diagram: This diagram shows a high-level view of a content delivery web application ("TO-BE") using CRISP. Internal components connect to a CRISP Broker, which manages resource resolvers, caching, and configuration. External systems connect through resource resolvers. Cache invalidation can be triggered by timers or external events. An Administrator manages resolver configurations.

The diagram illustrates how CRISP simplifies integration for applications:

• A single broker retrieves content and data from backend APIs.
• Configuration supports dynamic routing and execution at runtime.
• Automatic caching and cache invalidation improve performance.
• Resource link resolution is supported for external data and content.

CRISP addresses the architectural concerns as follows:

• Performance / Efficiency: CRISP provides generic resource object model caching. It generates cache keys based on resource space, operation, resource path, and variables, and retains cached data for a configurable interval. Applications use the ResourceServiceBroker API without handling caching or invalidation logic directly. Web-hooks can be implemented to invalidate caches as needed.
• Security: CRISP uses Spring Framework's RestTemplate for secure REST service invocations, with example configurations.
• Availability: Service components are designed to meet enterprise availability requirements.
• Configurability / Manageability: All configuration is stored in the repository. Administrators can update configurations at runtime without redeployment or server restarts.
• Modifiability: CRISP provides clean APIs and leverages Spring Framework to maximize productivity. The generic model API allows template usage without additional code for backend models.
• Cost-effectiveness: CRISP solves backend integration requirements generically, enabling high-quality integration through configuration and minimal code.

Module View

Diagram: This diagram shows the CRISP module structure, including submodules (CRISP API, CRISP HST, CRISP Repository, CRISP Core) and their dependencies. Feature modules depend on CRISP API and CRISP HST. A separate CRISP Resource Resolver Plugin depends on CRISP API.

This view outlines the CRISP module composition:

• CRISP API: Contains public APIs (interfaces and abstract base classes) for application integration.
• CRISP Core: Implements core components and services, including both public APIs and internal logic.
• CRISP Repository: Provides repository bootstrap configurations and an add-on module for configuration change event listeners.
• CRISP HST: Offers utilities and tag libraries for use in Bloomreach Content delivery tier applications.