Name: Leveraging a Singleton Class in Developer Extensibility – PET 2026
Uploaded: 2026-3-20
Duration: 604 s

Share feedback

<p>We are aware of intermittent issues in accessing the learning content</p>

We are aware of intermittent issues in accessing the learning content

Personalize your learning.

Why create an SAP account?

Enhance your learning experience

SAP Learning

Choose your subscription

Manage your subscription

Live Sessions

Hands-on Practice

Certification

My Learning

Ready to start learning?

This browser is not supported

Please try again later

Sorry, we encountered an error

Try again or reset results to continue browsing

We didn’t find what you’re looking for

To continue, please log in

Your session has timed out

Validate your skills and learning by completing the certification exam and gain a highly recognised accreditation.

Book your certification exam

Complete the assessment to validate your SAP PartnerEdge competency qualifications.

Ready to take your assessment?

Learn about the key features and essentials in the latest release to help you prepare for the Stay Certified assessment.

Prepare for assessment

Learn new skills you need at your own pace with our bite-sized lessons.

Prepare for certification

In your My Learning account you can view your certification and learn how to take your Stay Certified assessment.

Ready to take your Stay Certified assessment?

Explore {title} at SAP Learning. Find out more!

Assessment

Course Completion

Knowledge Badge

Overview

Support Resource

Certification Exam

Theoretical Exam

Schedule

External Course

Practical Exercise

Practical Test

External Hands-On

External Resource

Learning Journey

Learning Journey Assessment

Lesson

Live Session

Practice System

Quiz

Scenario Based Assessment

Course Assessment

Course

Stay Certified

Subscription

System Based Assessment

Test Out

Unit

Video

Video Playlist

Week

Want to remove this from your Learning List?

Your exclusive access to the SAP Learning Hub, event edition is ready. <link>Start learning now.</link>

Access activated

You can now register for free Live Sessions.

<div><div><div><div><div><div><div><div><div><div><div><div><div><div><div>SAP Business Suite Product Expert Training (PET) H1 2026 / Cross Topics / SAP Cloud ERP / SAP S/4HANA Cloud Public / Extensibility<br><br>With the goal to showcase the art of the possible with extensibility, this video will focus on using singleton classes in developer extensibility to solve a business case where key user extensibility's BAdI wasn't powerful enough.<br><br>Ask your questions in our <a target="_blank" rel="nofollow noopener noreferrer" href="https://community.sap.com/t5/enterprise-resource-planning-q-a/qa-p/erp-questions">community</a> using the PET_Enablement tag under “Question User Tags.” <br><br>Here is the <a target="_blank" rel="nofollow noopener noreferrer" href="https://d.dam.sap.com/a/fDzHwds/Leveraging-a-singleton-class-in-dev-extensibility-PET-H1-2026.pdf?r%E2%80%A6">slide deck</a>.<br></div></div></div></div></div></div></div></div></div></div></div></div></div></div></div>

Leveraging a Singleton Class in Developer Extensibility – PET 2026

Yeah, hi. Today I want to talk to you about using Singleton Classes in a Developer Extensibility with the intent of showcasing what is possible with Developer Extensibility, which is available with the three-system landscape. So to begin with, I do need to show the disclaimer slide where it talks about all forward-looking statements are subject to change, but in this case, I'm not going to be really talking about any forward-looking statements. So my name is Dennis Leslie. I'm part of the Cloud ERP Product Success team from North America, and I lead that group over there. So in three-system landscape, we have the option of developing extensibility, either using Key User Extensibility, where you can build a simple extensibility, like a custom field or a custom app, or you can use the side-by-side option with SAP Build or Pro Code in order to build something a little more complicated. But that's a loosely coupled application. Now, you also have the option of using Developer Extensibility, which is tightly coupled and it will be on stack as well. Just to draw a comparison between the different options,  Key User Extensibility is mainly a low -code, no-code adaptation that's available where you can build some really small and easy-to-use extensibility within the app so that it fits your requirement. On the other hand, you can also build something in SAP Build where you can customize maybe a Fiori app or also look into building your own custom workflows and things like that. And if you are a developer, you can also build a pro. You can use the Pro Code, which is ABAP developer code. there, you can then go ahead and build custom applications and custom extensions and things like that, and you can get as fancy as you want there. But usually that is a loosely coupled application because it lives in BTP and you're going to be using public APIs to connect into S/4HANA Cloud. But if you want something a little more performant and it needs to live within the S/4 system, you would try to use the On-Stack Developer Extensibility, where you're also an ABAP developer trying to build something, but this is going to be built on stack. So everything, you're using the internal objects in order to develop extensibility. So let's think about a particular business case and a challenge that is there. It could be that there is a scenario where you have a sales order and in the sales order item, the item gets replaced. It gets substituted because maybe of a plan substitution or for many other reasons, right? For whatever reason, the line item one got replaced by a second line item. Typically, in that case, there could be a scenario where the custom fields that were populated for the first line are not copied over into the second line. This could be like attributes for the line item, which maybe the customer was trying to customize that line item somehow. But because of the substitution that took place, it doesn't get copied over to the second line. And the challenge that you have is that if you were to use a typical body implementation that's available in Key User Extensibility it doesn't allow you to remember the extense- I mean the custom values that you had on line item one when you go into the line item two. Typically, these things iterate, and as it iterates, it completely forgets about what happened in the first line item. So if you need to remember what happened at line item one or maybe at the header level, right, and then you want to copy down into other line items. You need to be able to process this some way. And a typical body implementation doesn't allow you to do that. A Singleton class, therefore, is an option that you can use, right? And unfortunately, this is not possible within Key User Extensibility, but it's totally possible with Develop Extensibility. So what is a Singleton class? So imagine this. Let's say there are three different classes, and class A is trying to get an instance of the Singleton object, right? As it tries to make an object, the Singleton class figures out that there isn't an object available, so it creates one of those things, and then it provides it back to the class A. But when class B and class C come in and ask for an instance, it figures out that it already has an instance, and because of that, it doesn't create it. It just returns the existing instance. The benefit of something like this is that you could have invoked the class A as in like you could have invoked this Singleton object at the header level and then stored some value inside it or maybe you have invoked it at a line item one and then you've stored some value off and then when you get into the subsequent instance or subsequent call, then in that case, it doesn't create another instance. It just retrieves the existing instance. And so the value that's available gets copied over. So a solution, therefore, would be something like this, that you implement a Singleton class, which is done in Developer Extensibility, which allows you to create only just one instance of the object. And then you consume that Singleton class in a body, which can be implemented either in Developer Extensibility or in custom application. And in In this case, I will show you using both of it in combination, but then that's what we could do here, right? So for a demo purpose, let me switch over to the system itself. So before that, let me quickly show you this. So a Singleton class would look something like this, right? So you have a class implementation where if it finds that the instance is existing, if it doesn't exist, then it will try to create an instance. And if it does exist, then in that case, it will just return the current instance and so keeping something like this with methods which allows you to store values into it, allows you to retrieve it as well so that you don't have different instances created. Let's go into the system then. So here I have a body implementation done. And here you can see that there is a buffer which is really the Singleton class that I was just talking about. So there it creates an instance, and then once it's created an instance, it stores it off, and then it retrieves the value and tries to use it. So here you'll see that at the header line item, it stores the value. And then on the subsequent lines, what it does is that it retrieves that value, and then it stores it into the line items, this sales order items custom field. So here I'm using a custom field called Custom Delivery Group, but it could be anything, right? So you will see in my payload, I'm going to be populating something like that. So you have a payload here. Now, if I were to go and disable this code for a minute, so let me do that. So if I were to edit this body and if I were to just comment this line out and save and publish it, so it takes a little, takes a second to save it. So now that it's published, you can, so this is an OData API, so I'm just going to trigger OData API. So clicking on it, it will call the OData API and it will create a sales order for me. So there it's trying to trigger it. And then I got a sales order created. So now let's go look at the system itself. So if I were to look at the sales order, you will see that it did create a second line item. And in it, if you look at the custom fields, you will see that the custom delivery group is populated with the 32 that I passed in. But that's on line 10. If I were to go look at line 20 it doesn't exist. Its values are zero. Now, if I were to switch this back and I were to set this code and save and publish it. So this will now set the value for the line item two onwards of course in this case and you can always customize it. So that it will read it in the first line and it will store it off in the second line. So let's do this again. So I'm going to use the ODataAPI and post it again. And it will create a sales order now we have a different sales order. So I'm going to come back into the system and if I were to go out and look up this new sales order in it as well it has created two line items and if I look at the first line item you will see under the custom fields that the value is set but if you look at the line item 20, there as well, the value is set. So this essentially shows that I could use a Singleton class to do something like this. So the intent over here was just to showcase what is possible within Developer Extensibility and of course there are many other courses like this available and you can go to these links in order to find that. There's also many other resources that are available that you can look through this as well. If you do have questions do send us an email at this email ID and we can try to help you out. Thank you very much.