Fiori for ABAP - Overview

Table of contents

• Introduction
• Annotations
• Service
• Creation
• Extension
• Backup
• JavaScript
• Conclusion

In this article, we explore how much Fiori knowledge we actually need for our work when developing RAP (ABAP RESTful Application Programming Model) applications.

 

Introduction

A while ago, we addressed the question of how much Fiori an ABAP developer actually needs in their daily work. We discussed the various reasons why we should return to full-stack development to maintain complete control over our applications. Therefore, we recommend that you first read this article to gain the necessary background information. In this current post, we will revisit the basic components we need to create and extend a Fiori application without much effort, and what the standard already provides.

 

Annotations

RAP applications are primarily developed annotation-driven in the backend. We create a large number of UI annotations directly in the data model, which at first glance doesn't necessarily suggest a clean separation. However, they are an important component for developing applications quickly and easily, and for modeling UI behavior very closely to ABAP and the actual application. Therefore, our first recommendation is always to keep the UI annotations in the backend (ideally in metadata extensions) so that corresponding adjustments can be made without having to redeploy the application. This gives you the most flexibility and saves you the additional step of deploying a new Fiori artifact. In the simplest case, this is a classic Fiori Elements application that has no internal logic of its own, as the majority of the logic resides entirely within our RAP stack.

 

Service

Nowadays, services should primarily be generated using OData V4. Using version V2 is hardly recommended anymore. Most modern plugins, extensions, and even the Fiori Elements Extension API are now primarily based on OData V4. This gives you the greatest possible flexibility and the full range of functions you need for your modern Fiori development. There may still be very rare exceptions where an OData V2 service is used (for example, for specific legacy requirements), but generally, you should make sure to use the latest version with OData V4.

 

Creation

Once we have defined all our UI annotations, we can begin the actual creation of the application. Here, you should first ask yourself: Which software do you actually want to use to create your Fiori artifacts? You currently have two tools to choose from:

1. BAS - The SAP Business Application Studio is the standard product that comes with BTP and represents VS Code in a cloud container.
2. VS Code - A local installation of VS Code with the corresponding plugins for Fiori development (SAP Fiori Tools).

 

Here, working with the Business Application Studio is recommended, since you only want to generate your Fiori application and don't want to spend too much time in the actual IDE. The disadvantage of VS Code is that the IDE and the plugins always need to be kept up to date, which wastes a lot of time just updating the software instead of working on the actual app. Here you should simply consider your personal preferences.

Most tutorials will be shown using BAS. However, this could change in the coming months when the VS Code plugin for ABAP development (ADT) is released. In principle, full-stack development can then be carried out entirely in VS Code. This eliminates the need to switch between different tools and allows the entire process to be modeled in a single tool. This could be a crucial advantage for VS Code in the future, depending on how well the plugin ultimately works for ABAP development.

 

Extension

Once you have generated your Fiori Elements application, you may need to make extensions to the application. Various functions within your development environment are available for this purpose, such as Guided Development or the corresponding Extension APIs. Furthermore, there are tools like the Page Map that you can use to manage entities and mappings. However, based on our own experience, it is generally recommended to make as few extensions as possible directly in the UI application, unless they are truly complex use cases. You should always keep in mind: The more complex the use case and the more custom extensions you have in your Fiori application, the more maintenance effort you will need to plan for in the future. Therefore, it is recommended to initially stick as closely as possible to the standards and templates as delivered by SAP.

 

Backup

Have you finished generating and deploying your application? From here on, it's essentially just a matter of backing up the actual application data. While the files are stored in cloud storage in the Business Application Studio, they are not permanently protected from deletion there. Therefore, the final step is almost always to store the entire application in a Git repository. For this, you should use a suitable Git repository that is used in your company. Currently, a cloud provider can be used here, or a product that is accessible via the Cloud Connector.

Why do we want to back up the actual application even though we have hardly made any manual changes to the code? The reason is quite simple: Important configurations are present, such as certain parameters that we need for navigation in the Fiori Launchpad. These configurations are also needed if, for example, we want to perform an undeployment of the actual application. Furthermore, there may be customizations to text (i18n files) or other minor details. To ensure the next developer can build on the exact state we deployed in the system, we back up all resources centrally.

 

JavaScript

One of the big questions still remains: What about the use of JavaScript, and how much of it do we as ABAP developers really need?

This question isn't necessarily easy to answer, but generally, there's enough information and examples from SAP to get by without JavaScript code. Furthermore, we've now entered the age of AI. This means that AI can also help us create JavaScript code snippets or answer business-related questions. From personal experience, we can say that in the applications we've built so far, we've hardly needed any JavaScript. Therefore, you shouldn't worry too much about learning JavaScript or the entire SAPUI5 framework in detail right now. It's best to start with the RAP basics, build your applications, and then selectively assess what you really need to extend in the user interface.

 

Conclusion

This should now give you a rough overview of what you actually need to start developing in the context of RAP, to build your first applications, and to deploy them. Basically, you don't need to worry about being overwhelmed by UI5 and JavaScript. Fiori Elements and the RAP framework will take a huge amount of work off your hands.