Mulesoft | Shared Libraries

Overview

In Mule 4, reusability is a key feature, significantly enhancing the development lifecycle (SDLC) by enabling the reuse of various components across multiple projects. This includes RAML fragments, DataWeave code snippets, HTTP resource configurations, and database configurations within a Mule application. For cross-application sharing of resources, domain projects can be used in an On-Premise deployment model. In CloudHub, shared libraries can be used for reusability, including common flows, error handlers, and DataWeave scripts, which can be added as dependencies to any Mule application.

Benefits of Shared Libraries in Mule 4

1. Reusability

• Description: Shared libraries allow the creation of modular components that can be reused across multiple projects.
• Benefits: Promotes consistency, reduces code duplication, and streamlines development efforts.
• Example: A common DataWeave transformation script used in various Mule applications.

2. Maintainability

• Description: Updates and improvements can be made in a centralized location.
• Benefits: Ensures consistent changes across all projects, simplifying maintenance and reducing the risk of inconsistencies.
• Example: Updating an error handling routine in a shared library applies the change across all dependent projects.

3. Standardization

• Description: Establishes standard practices, conventions, and configurations.
• Benefits: Facilitates consistency and enforces best practices.
• Example: A standard logging mechanism provided by a shared library ensures uniform logging across all applications.

4. Collaboration

• Description: Promotes collaboration among development teams through shared resources.
• Benefits: Enables knowledge sharing and leverages collective expertise.
• Example: Developers contributing to and using a shared library for common utility functions.

5. Development Efficiency

• Description: Accelerates development by providing pre-built components.
• Benefits: Allows developers to focus on business-specific logic, reducing development time.
• Example: Using a pre-built connector configuration from a shared library.

6. Versioning and Governance

• Description: Provides version control mechanisms for shared assets.
• Benefits: Ensures compatibility and maintains control over asset usage and evolution.
• Example: Managing different versions of a shared library to ensure compatibility with various applications.

7. Flexibility

• Description: Allows customization and extension to meet specific project requirements.
• Benefits: Promotes agility and scalability.
• Example: Extending a shared library’s functionality without impacting other projects.

Creating a Common Library Module

Prerequisites

• Anypoint Studio 7.x
• Maven (version 3.2.3 or later)

Steps to Create a Shared Library

Creating a common/shared library is similar to implementing a Mule application in Anypoint Studio, with some adjustments to the traditional pom.xml used in Mule API development. The process assumes that Maven is configured on your machine and that you have Exchange credentials with a contributor role added to settings.xml.

Create a New Project in Anypoint Studio:

• Go to File -> New -> Mule Project and name the project meaningfully, e.g., common-application-resources. This library will replace common error handlers and health check flows in any Mule application it is added to.

Create Configuration Files:

• Create a configuration file for each functionality, such as error-library.xml for error handlers and health-library.xml for health check flows.

Make Changes to the pom.xml:

• Set appropriate values for groupId, artifactId, and version. The packaging value should be mule-application.
• These values will be necessary when referencing this library in other Mule projects.
• Add a classifier tag to declare that this Mule application is a plugin by including a classifier element within the configuration of the mule-maven-plugin under the build -> plugins -> plugin -> configuration section.

Add Required Dependencies Used in the Library:

• Include the dependencies for the modules utilized in the library. For instance, if you're using HTTP requests, add the HTTP connector dependency with the appropriate scope.
• Similarly, if other modules are used, add their respective dependencies along with the scope element in the pom.xml.

Add Common Business Logic to the Configuration Files:

• Add business logic to the configuration files by dragging and dropping message processors from the palette and configuring them.
• In error-library.xml, create an error handler within the error handling scope.
• In health-library.xml, create two flows: one for liveness and the other for readiness endpoints.

Note: If errors occur regarding configurations in health-library.xml, it might be due to the absence of HTTP request configurations. To address this, create a stub.xml file with dummy global configurations, a flow reference element, and place it in src/test/resources.

Install Library to Local Maven Repository:

• Navigate to the common-application-resources project folder.
• Open the command prompt and execute mvn clean install. This command installs the application as a Maven dependency to the local repository.

If everything goes well, we will see the build as a success. You can check .m2 folder or your maven repository folder under the org Id folder for this library as a dependency

Publish to Exchange as an Asset:

• To publish to Exchange, run the command mvn deploy in the project folder.

How to Refer to this Artifact:

• To use this library in a Mule application, add the dependency coordinates of this library to the pom.xml file like any other dependency, along with <classifier>mule-plugin</classifier>.
• For example, in the API where you want to use this library, create a health.xml configuration file with a sub-flow called dependency-liveness-status to check the health of downstream APIs and route traffic.

Once the dependency is added, you'll observe the libraries in the project, and the stub.xml created in src/test/resources may not be referenced. To reference these libraries, you can use the import feature in global elements by specifying the particular library you wish to import.

In conclusion, shared libraries in Mule 4 offer significant benefits in MuleSoft development, enabling organizations to capitalize on reusable components, elevate maintainability, and enhance development efficiency. By adopting shared libraries, organizations can implement standardized development practices, foster collaboration, and streamline integration projects for sustained success.