SAP ABAP Advanced Cookbook

4 (1 reviews total)
By Rehan Zaidi
  • Instant online access to over 7,500+ books and videos
  • Constantly updated with 100+ new titles each month
  • Breadth and depth in over 1,000+ technologies
  1. ABAP Objects

About this book

ABAP (Advanced Business Application Programming) is SAP’s proprietary 4th Generation Language (4GL). SAP core is written almost entirely in ABAP.

ABAP is a high level programming language used in SAP for development and other customization processes.

"SAP ABAP Advanced Cookbook” covers advanced SAP programming applications with ABAP. It teaches you to enhance SAP applications by developing custom reports and interfaces with ABAP programming.

This cookbook has quick and advanced real world recipes for programming ABAP.
It begins with the applications of ABAP Objects and ALV tips and tricks. It then covers Design Patterns and Dynamic Programming in detail.

You will also learn the usage of quality improvement tools such as transaction SAT, SQL Trace, and the Code Inspector.

Simple transformations and its application in Excel Downloading will also be discussed, as well as the newest topics of Adobe Interactive Forms and the consumption and creation of Web services. The book comes to an end by covering advanced usage of Web Dynpro for ABAP and the latest advancement in Floorplan Manager.

Publication date:
December 2012


Chapter 1. ABAP Objects

In this chapter, we start with recipes for ABAP objects. This chapter is designed to provide useful recipes related to the storage of ABAP objects in shared memory and the database (persistent objects), as well as some useful design patterns. In this chapter, we will look at ways of:

  • Creating a shared memory object

  • Creating a persistent object

  • Creating classes based on factory methods

  • Creating classes based on singleton design pattern

  • Creating classes based on adapter pattern



This chapter explores recipes related to ABAP objects. Two useful features of the object-oriented ABAP are storage options in the shared memory as shared objects, and in the database as objects of persistent classes. The details about both the prerequisites as well as the necessary steps needed to created shared memory-enabled objects and persistent objects will be discussed later in this chapter.

Moreover, design patterns are very important in object-oriented programming. In this chapter, we will see how to implement three of them using ABAP objects, namely the adapter, singleton, and the factory design. We will create a class with a factory method design. Later, we will show how this class may be modified in order to behave like a singleton class. Finally, we will see how an object of one class may be converted to that of another using an adapter class. The examples are kept simple in order to emphasize on the design pattern concept.

For this chapter, we assume that the reader has basic knowledge of the ABAP objects, and is familiar with the class-builder transaction.


Creating a shared memory object

This recipe shows how to store the instances of your classes in the shared memory of the application server. A number of programs may access these objects that reside on the application server shared memory.

Two classes are necessary for shared memory, namely the area class and the area root class. The root class is necessary for storing (encapsulating) the data that are to be stored in the shared memory. An area class may comprise of various instances that may consist of a number of versions.

An important concept shown in this recipe is the CREATE OBJECT statement with the addition AREA HANDLE. This will create the object in the application server that is shared memory pointed to by the area handle myarea.

Getting ready

Prior to writing the code for storing objects in shared memory, an area root class must be created and a shared memory area be defined using transaction SHMA.

The steps required for creating a root class are:

  1. Call transaction SE24; enter a suitable name to your root class, as shown in the following screenshot. On the Properties tab, we need to make sure that the Shared-Memory checkbox is switched on.


    Downloading the example code

    You can download the example code files for all Packt books you have purchased from your account at . If you purchased this book elsewhere, you can visit and register to have the files e-mailed directly to you

  2. We have named it ZCL_MY_ROOT. We will then define two Instance Attributes, NUMBER and NAME, having private visibility, as shown in the following screenshot:

  3. Two suitable methods, SET_DATA and GET_DATA, are also added to the class. The SET_DATA method contains code that imports number and name and assigns to the attributes NUMBER and NAME of the class. The GET_DATA method does just the opposite, that is, it exports the NUMBER and NAME attribute for a given shared memory object.

  4. Next, the shared memory area should be created. This is done via transaction SHMA.

  5. Enter a suitable name and click on the Create button. We have typed the name ZCL_MY_EMP_AREA. On the screen that appears, enter the description of the area. Also, enter the name of the root class created earlier in the Root Class field. You may leave the Client-Specific Area checkbox unchecked as it is not required for our recipe. Now, save your entries. Refer to the following screenshot:

  6. This will also generate an area class by entering the same name ZCL_MY_EMP_AREA.

  7. This area class will contain the necessary methods used for reading, changing, and creating the area, such as ATTACH_FOR_UPDATE, ATTACH_FOR_READ, and ATTACH_FOR_WRITE.

How to do it...

For creating the set of code that writes object's contents to the shared memory, follow these steps:

  1. Two object references my_handle and my_root are defined, one for area class and the other for root class.

  2. The static method attach_for_write of the area class zcl_my_emp_area is called.

  3. The CREATE OBJECT with the area handle, my_handle must then be called.

  4. The root and the created area instance must be linked using the set_root method of the handle.

  5. The set_data method is called with the relevant number and name.

  6. The detach_commit method of the area class is then called.

How it works...

In the shared memory-writing program, the statements collectively make the writing of object in the shared memory. Let us see how the program code works.

An area instance version needs to be created before any data may be written in the shared memory on the application server. The attach_for_write static method is used for this purpose and returns a handle to the area instance created in the application server memory. This imposes write lock on the version.

The CREATE OBJECT statement is then called with the name of the created handle. This creates a root object in the area instance of the shared memory. The link between the area instance and the root class is created using the set_root method. The set_data method is then called for the root reference my_root and supplied with the name and number of the employee, which are then stored in the shared area. Finally, the detach_commit method is called and the write lock is released.

Once the program has run successfully, you may see the created object in the shared memory using the shared memory transaction SHMM. This will appear as your area class name ZCL_MY_EMP_AREA. Refer to the following screenshot:

Double-click on the name of area to view the details, as shown in the following screenshot:

There's more...

The read program is somewhat similar. However, instead of the attach_for_write method used earlier, we will use attach_for_read. The same instance name is passed and the handle is received. The method imposes a read lock on the area instance. Then, the get_data method of the root object is called using the area handle, my_handle. This returns the employee name and number stored earlier into the variables name and number respectively.

Finally, the detach method is called and the read lock is released.

While creating the shared memory area, if we select the Transactional Area checkbox, the area becomes transactional. In this case, the modifications to the area instance versions are not active immediately after the call of detach_commit method. Rather, they become active when the next database commit is executed.


Creating a persistent object

ABAP objects provide a persistent object service that allows the developer to store objects in the database. The values of the attributes of the object are stored in appropriate fields of the database table specified. This recipe shows how to define persistent classes and then how to call them in your application programs.

Getting ready

Prior to storing objects in the database, a suitable database table with the name ZEMP_TABLE is created to store the values of the objects' attributes. Two fields are defined, NUMBER1 and NAME (the field name NUMBER was not allowed, so NUMBER1 has been used as the field name). Refer to the following screenshot:

How to do it...

Once the database table is defined, a persistence class must be defined. In order to define persistent classes, follow these steps:

  1. Call transaction SE24. Enter a suitable name of the persistent class to be created. We will create a class by entering the name ZCL_MY_PERSIST. Enter the name in the Class field and click on the Create button.

  2. Enter a suitable description in the field provided. Make sure that the Persistent Class indicator is selected, and click on Save.

  3. The programmer may only modify the methods HANDLE_EXCEPTION and INIT.

  4. Click on the Persistence button. Then, enter the name of the table that was created for storage of data( in our case, we will enter the name ZEMP_TABLE). Refer to the following screenshot:

  5. This will take you to the mapping editor. The lower part of the screen will show Table/Fields. Double-click each of the field that is to be included and stored as attributes of the persistent class. The selected field appears in the area earlier (for example, the NUMBER1 field as shown in the following screenshot). Click on the Set attribute values button to include the field.

  6. This will transfer the selected field in the topmost area of the editor.

  7. Similarly, the NAME field must be included.

  8. All the mapped fields will appear at the top area of the mapper. The Number1 field will appear as a business key, as show in the following screenshot:

  9. Upon activation of the persistence class, the system asks for activation of the actor class as well. Click on Yes, as shown in the following screenshot:

  10. The class ZCL_MY_PERSIST is created and necessary methods needed for the persistence service are included. An actor class is also created with the class. The agent class has been generated by the name ZCA_MY_PERSIST. There is one base agent class generated as a result. In total, three classes are generated, the persistent class, the agent class, and the base class of the agent.

  11. The class ZCL_MY_PERSIST contains methods for setting and getting the values of the attributes NAME and NUMBER1. Note that no SET method is generated for the key field, in our case NUMBER1.

  12. The agent class provides number of useful methods related to the persistent property. Important methods, such as create_persistent, delete_persistant, and get_persistent are provided. The methods are implemented in the superclass zcb_my_persist of the agent class zca_my_persist.

How it works...

During the generation of the persistent class zcl_my_persist, two additional classes are generated. These are the actor (agent) and the base agent classes having the names zca_my_persist and zcb_my_persist respectively. The base agent class is generated as abstract (that is, no instance can be constructed from it), and cannot be modified. It is created in a separate pool class from zcl_my_persist. The agent class zca_my_persist may be extended, as well as the loading and saving methods may be modified.

The instantiation mode of the persistence class may be set as abstract or protected. In our recipe, we have chosen the instantiation mode as protected (which means that only instances may be created from within the class or its subclasses). However, making the instantiation mode of a persistent class as protected makes the generated base agent class a friend of the persistent class (in the world of ABAP objects, a friend or its subclasses may create instances of the class in question).

The coding for this recipe declares two references, emp and agent, to the persistent class zcl_my_persist and the agent class zca_my_persist, respectively. Next, the static factory method agent is called for the class zca_my_persist (agent class). The reference returned is stored in the variable agent.

The agent class contains the method create_persistent required for storing the data into the database (this is analogous to the concept of insertion in database table).

The most important part is the calling of the create_persistent method that is passed the number and name that is to be stored. The employee with the number 00000017 and name John Reed is created and reference is returned in emp. Finally, the COMMIT WORK method stores the data of the emp object into the table created earlier in this recipe. One row with the number and a name is added to the table ZEMP_TABLE.

For reading the stored value related to the employee number 00000017, a number variable is declared and assigned the value 00000017. The static method agent of the zca_my_persist class is called in order to get a reference to the agent. The get_persistent method is then called and the number (in our case, 00000017) is passed. This method returns the entire object emp pertaining to the employee number. You may then call the get_name method of the zcl_my_persist class for the emp object in order to retrieve the employee name.


Creating classes based on factory methods

One important design pattern that is used in object-oriented ABAP is the factory design. This allows you to create objects of a particular class either via a factory class or via factory method defined within the class. The emphasis of this recipe is to design a class that supports the creation of its objects via a factory method, rather than direct instantiation outside the class via CREATE OBJECT statement.

A factory method is a static method that creates and then returns (as a parameter) a reference to the object of the class it belongs to. The code for the creation of the object is contained within the factory method. This recipe shows the factory design. You may further modify to enhance the structure in order to suit your needs

We have referred to the coding of the standard cl_salv_table class factory method for creating the class shown in this recipe. The class created in this recipe will be used in the subsequent recipes of singleton and adapter design pattern.

Getting ready

For the sake of this recipe and the ones that follow, we will focus on an employee and name example. The class will encapsulate an eight-character number (in numeric form) for the employee number 00000014 and a 30-character field for the employee name. For example, there can be an employee John Reed with number. This will be stored in the private attributes of the class as Name and Number.

How to do it...

For creating a class as a factory method design, follow these steps:

  1. Create a class definition for fac_meth_class in the program. The factory method is a static method for the class and is defined via CLASS-METHODS. The class definition contains the addition create private in order to stopthe instantiation of the class from outside via CREATE OBJECT. A constructor is defined that allows setting the value of the number and the employee name.

  2. The private attributes employee number and name are defined, as it is based on the dictionary data elements persno and smnam respectively.

  3. The static method factory imports the name and number of the employee to be created and returns the employee object employee_obj of the object reference fac_meth_class. The constructor takes as input the number and the employee name.

  4. The implementation of the fac_meth_class object reference is then created. The code for the factory and the constructor is written here. The factory method receives the number and the name of the employee to be created. It includes the CREATE OBJECT statement for creation of the employee object.

  5. The constructor assigns the number and employee name to the corresponding private attributes of the newly constructed object. A WRITE statement is also included that outputs the name and number of the successful created employee.

  6. Finally, the call for the factory method is included. The static method of the fac_meth_class=>factory object is included and passed with the number and name of the employee to be created. A code shows two such method calls for object references emp1 and emp2, that is, employee 00000012 and 0000014.

How it works...

When the program calls the static factory method, the code within the factory method is called for each of the two objects emp1 and emp2. The factory method triggers CREATE OBJECT statement, which creates a new object and calls the constructor.

The constructor is called twice, once for each of the two instantiated objects emp1 and emp2. This prints the message successful creation for emp1 and emp2.


Creating classes based on singleton design pattern

A singleton class is a class that can have only one instance at a time. Any attempt to create a second or more instances should not be allowed. This recipe shows how to create a class based on the singleton design.

Getting ready

We will use the same class created in the last recipe of factory method. We will make few changes to the class so that we can prevent the creation of multiple instances of the class. We will make a copy of the class (program) shown in the previous recipe and modify it. The name of the copy is singleton_class.

How to do it...

For creating a singleton class, follow these steps:

  1. Make sure the CREATE PRIVATE addition is included in the singleton class definition.

  2. Within the definition, a static attribute number_of_instances having type integer is added to the private section.

  3. The implementation of the class is then written. The factory method has to be slightly modified in order to force the singleton characteristic.

  4. In the implementation of the singleton class, the factory method now contains an IF statement that first checks the number of instances already there when the factory call is made. If the first instance is being created (that is, number_of_instances equals 0), the employee object is created and number_of_instances is set as 1. An ELSE condition is included to output a message if one instance already exists.

How it works...

Similar to the previous recipe, we try to instantiate two objects emp1 and emp2, having number 0000012 and 00000014 respectively. However, in our singleton class, we have added an attribute number_of_instances, which keeps track of the number of class instances that already exist. Upon creation of the first object, the factory method increments this static attribute to 1. On the second object creation attempt, the IF statement does not allow the CREATE OBJECT statement to be called a second time. The result is that the second object is not created. No further attempts of object creation will be allowed. Rather, a message saying that only one object instantiation is allowed is outputted for the second object creation attempt.


Creating classes based on adapter pattern

Another important design pattern is the adapter design. As the name suggests, the adapter design is used for conversion of one object into another object belonging to a different class. An adapter class will have a method that takes as input the object reference that is to be converted and outputs it into the other object reference format.

We have referred to the cl_salv_tree_adapter standard class while making of this recipe.

Getting ready

In order to demonstrate the adapter, we need two classes (input class and output class). The input class will be the fac_meth_class created earlier. For the output, we will create another class fac_meth_class2. This will serve as the class, into the format of which the input object will be converted.

It is without a factory method for sake of simplicity. It contains employee number and employee name but the format of these two is different from the classes shown in the previous recipes. The employee name of this class is based on data element emnam, whereas the number is a character without zeros having length as eight. The name is of the form (firstname lastname), meaning John Reed will be stored as John Reed and not Reed John as in the previous recipes. The constructor outputs the message, Converted employee created.

We will use the same class used previously as the input object for the adapter method.

How to do it...

For creating a singleton class, follow these steps:

  1. Create a deferred definition of the adapter class adapter_meth_class that we are going to create in the next step.

  2. Specify the adapter_meth_class as a friend of our fact_meth_class class in the definition via the FRIENDS addition.

  3. The adapter class is then defined. It contains a static adapter method adapter that imports an object based on fac_meth_class and returns one in the fac_meth_class2 format.

  4. The implementation of the adapter class is then created. It contains the code of the adapter method. The adapter method will convert the incoming number of the employee from numeric to character format. In addition, the name of the employee is converted to the firstname lastname format. The new object based on the second class fac_meth_class2 is then created and returned as an exporting parameter of the method.

  5. While calling the adapter method, you first create an object based on the fac_meth_class class that is a factory method (for illustrative purpose), similar to the previous recipe for the object reference EMP. This is then passed on to the static adapter method of the adapter_meth_class. The adapter class returns the converted object in the second format.

How it works...

When the program calls the static method adapter of the class adapter_meth_class , the code in the adapter method is executed. The adapter method calls the necessary code for converting the number into the character format and any zeros are removed from the number. In addition, the SPLIT statement is called for converting name of the employee in the (first name last name) format such as converting Reed John into John Reed. Finally the CREATE OBJECT is called in order to create the object in the converted class format . This triggers the constructor for the converted class fac_meth_class2 that outputs the message "Converted: Employee Created having number 1234" and name John Reed. Since we called the factory method of the original fac_meth_class before the adapter method call, the original constructor was also called and message printed also.

See also

  • Design Patterns in Object-Oriented ABAP published by SAP-Press

About the Author

  • Rehan Zaidi

    Rehan Zaidi has more than 13 years of SAP experience and has been writing about SAP topics since 2001. He co-authored an ABAP programming training manual for a course taught in North America and has written a number of SAP books and articles about ABAP, workflow, HR functional and technical users, and SAP user experiences. Rehan has carried out support and implementation projects involving various areas of ABAP and workflow, and has worked in technical and functional areas of SAP ERP HCM. He holds bachelor and master’s degrees in computer science. You may reach Rehan via e-mail at [email protected]

    Browse publications by this author

Latest Reviews

(1 reviews total)
bon achat. bon rapport qualité prix
Book Title
Access this book, plus 7,500 other titles for FREE
Access now