Wood J. Object-Oriented Programming with ABAP Objects

Подождите немного. Документ загружается.

UML Tutorial: Advanced Activity Diagrams

im_pub1isher - 'SAP PRESS*.

* Display the updated document in a browser:

gr_reading_list->display( ).

Listing 12.12 Sample Program to Read an Existing List

Edit Goto SYStem Help

""Ho ©0© o

version=*l.O* encode ='utf-8* ?>

- <R<?adingList>

- <Recommen<JedBooks>

<Tit)e >ABAP Basics </Titie>

<Authcr: Guenther Faerber</Author>

<Author >Julla Klrchner</Author>

</Book>

<8©0k »sbn='978-1-59229-039 0'>

<Title>Tlie Official ABAP Roference</T'Oe>

<Publisher >SAP PRESS</Publ>sher>

<Authcr: Morst Kollor-:/Author >

</BOOk>

</R«comm«ndedBooks >

</ReadingList>

Figure 12.4 Displaying the Revised XML Document in a Browser

12.6 UAAL Tutorial: Advanced Activity Diagrams

In Section 8.6, UML Tutorial: Activity Diagrams, you learned how to model basic

process flows using activity diagrams. In this section, we will expand upon these

basic capabilities and look at some of the more advanced flow control elements

provided for activity diagrams in the UML 2 standard.

The activity diagram shown in Figure 12.5 depicts an employee leave request

workflow process. To effectively trace this process across all of the relevant par-

ties/systems, the diagram is split into rectangular swim lanes called partitions.

Partitions can be labeled to depict a class, a person/role, a system, an organiza-

tion. and so on. The basic idea here is to show who does what in the process flow.

325

12 | Working with XML

In this case, an Employee initiates the workflow process by creating a leave

request. However, in this action (i.e.. Create Leave Request).you will notice that

there is a little "fork-like" icon in the left-hand side of the action icon. This nota-

tion indicates that the Create Leave Request action is actually a sub-activity

whose details are described in another activity diagram.

Figure 12.5 An Advanced UML Activity Diagram

Tracing the flow in Figure 12.5, you will notice that after the leave request is cre-

ated, the next action is to submit the request to a workflow engine. This submis-

sion process is depicted using special action types called signals. The use of signals

326

Summary 12.7

here helps to signify the fact that the workflow process receives the request from

an external process. Signals can also be used to depict other complex synchronous

and asynchronous messaging scenarios.

After the leave request is received by the workflow engine, it is forwarded to the

employee's supervisor (via email, for instance). At this point in time, the work-

flow process is in a holding pattern as it waits on a couple of potential outcomes.

This holding pattern is depicted using a fork element. Here, one of two things can

happen.

• Ideally, the supervisor will receive the request (again via a signal action), pro-

cess it. and send a response back to the workflow engine.

• However, if the supervisor hasn't responded within 24 hours, the process

should terminate. This 24-hour watch period is depicted using a time signal

(i.e., the "bow-tie" icon shown in Figure 12.5).

In cither case, the process comes together again in a join clement. From here, an

email response message (favorable or otherwise) is forwarded back to the initiat-

ing employee, and the process terminates as per usual.

Another element of the activity diagram that we have not yet considered is the

diamond-shaped decision node shown in Figure 12.5. This node looks just like the

merge node described in Section 8.6, UML Tutorial: Activity Diagrams. However,

in this case, there is one input and multiple outputs as opposed to multiple inputs

and a single output. Each of the outputs of

decision node is marked with a spe-

cial guard text (e.g.. [Approved] or [Rejected]) that describes the condition(s) in

which that particular output path is selected. As you might expect, decision nodes

are veiy good for depicting an IF/ELSE or CASE statement in a flow.

In many ways, even the advanced elements described in this section barely

scratch the surface with regards to the types of things you can model using activ-

ity diagrams. To learn more about activity diagrams, see Martin Fowler's UML

Distilled (Addison-Wesley. 2004).

12.7 Summary

In this chapter, you applied the object-oriented skills that you have gained

throughout the course of this book to learn how to work with the object-oriented

iXML library. The design techniques used in this chapter have been consistent

327

12 | Working with XML

with one of the main themes of this book: to encapsulate complexity behind the

boundaries of

class. In this case, you wrapped XML processing details inside of

an interface that is more closely aligned with the concept of

reading list. Users of

class lc1_reodlng_list can take advantage of this abstraction without under-

standing how the iXML library is being used behind the scenes.

This brief introduction to XML provided the foundation necessary for you to

begin branching out and looking at other XML-based technologies such as XSLT,

Web Services, and so on. If you are interested in learning more about some of

these concepts, read XML Data Exchange Using ABAP (SAP PRESS Essentials,

2006).

328

13 Where to Go From Here

By now. you should feel equipped to begin applying object-oriented program-

ming techniques in your next project assignment. Often, this transition period

can be difficult in an environment where the majority of your peers operate in a

procedural mindset. Here, it is more important than ever to stick to the basics and

develop well-encapsulated classes with high cohesion.

After all, objects should be easy to use even if they weren't so easy to implement.

Such objects are excellent teaching aids that typically spark a lot of interest within

the project as more and more developers begin interfacing with your classes. In

other words, ifyou build it, they will come.

In many respects, this book only reveals a very small part of the world of object-

oriented programming. Clearly, understanding object-oriented syntax and basic

theoretical concepts is important. However, to maximize your effectiveness as an

object-oriented programmer, you need to train your mind to think in object-ori-

ented terms. This process takes time and experience.

One way to accelerate the learning curve is to spend time looking at quality

object-oriented designs created by seasoned object-oriented developers. A good

place to start is to look at the catalog of designs outlined in Design Patterns: Ele-

ments of Reusable Object-Oriented Software (Addison-Wesley, 1994). Also, for an

ABAP-centric perspective of some of these design patterns, see Design Patterns in

Object-Oriented ABAP (SAP PRESS, 2006).

I hope that you feel that your investment in this book has been worthwhile. Hav-

ing a good foundation in object-oriented skills should position you well as SAP

continues to migrate away from procedural ABAP. For a glimpse into the future,

I highly recommend the book Next Generation ABAP Development (SAP PRESS,

2007).

329

Appendix

A Debugging Objects

B The Author

A Debugging Objects

you start working with objects in your programs, it is useful to be able to inter-

actively step through a program to see the values assigned to various attributes

and trace through the program flow logic. In this appendix, we will look at how

to use the ABAP Debugger tool to debug ABAP Objects classes. The material in

this appendix is presented assuming thatyou have some familiarity for debugging

programs using the ABAP Debugger tool. If you have not used this tool before,

you should read through the SAP online help documentation (http://help.sap.com)

because basic concepts are not covered in this section.

Prior to Release 6.40 of the SAP Web AS, there was only one debugger tool avail-

able to developers. However, over time, certain limitations in this tool prompted

SAP to implement the New ABAP Debugger tool using a different and more flex-

ible architecture. Although the details of the differences between these two

debugger types are beyond the scope of this book, the discussion of debugging

objects has been separated into two sections so that you will understand how to

use both tools to debug objects.

A.1 Debugging Objects Using the Classic ABAP Debugger

For the most part, you will find that dealing with objects in a debugger session is

quite similar to working with normal data objects, procedures, and so on. Never-

theless, there are elements of the debugging process that are unique to objects.

This section highlights some of these particular concepts.

A.1.1 Displaying and Editing Attributes

You can display an object in ABAP Objects in a debugging session by performing

the following steps:

1. If you are not already in the FIKLDS display mode, select this display mode by

clicking on the FIELDS button underneath the application toolbar.

333

Debugging Objects

2. Select the object reference variable that points to the object you want to inspect

by double-clicking the reference variable name in the ABAP program code dis-

play. Alternatively, you can enter the reference variable name in the FIELD

NAMES section and press the (3 key (see Figure A.l).

ABAP Debugger

IS3IB3 E

«]{• Watthpoint |

Fields Table | BreaHwr.ls | Watchpo nts | Calls \ Overview! Settings

Main Program

Source code of

ZALVFLI6HT

ZALVFlISHT_CLASSES

157

METHOO SHOW_ORO (LCL_OUERY_CTRL)

CHAK6IN6

t.tabie = flightJ 1st

CATCH CX_»a1v_i$g

ENDTRY.

Enable the standard ALV toolbar

lr_functlons = grld->get_funct1ons( ).

lr_Tunctlons->s«t_a11( abap.true )

that »e can respond to double-click events on the grid

lr_event$ = grid->get_ov»nt( ).

SET HANDLER »e->on_double_cllck FOR lr_events.

Display the ALV grid:

grid->di$p1ay( )

ENDUETHOD

Field names Field contents

grid {0 15"\CLASS=Cl_SALV_TABLE}

SY-SUBRC 0

SY-TABIX 2 SY-D6CNT 14 SY-DYNNR 1006

Figure A.1 Selecting an Object Reference Variable for Display

you can see in Figure A.1, the FIELD CONTENTS display for an object reference

variable only shows the internal object ID of the object pointed to by the object

reference variable. To view the values of the attributes in this object, you must

double-dick on the object ID. This opens up the OBJECT display mode view

shown in Figure A.2.

334