SAP PI 7.

3 Training Material

Page 1 of 153
Why do we need XML parser?

We need XML parser because we do not want to do everything in our application from scratch, and
we need some "helper" programs or libraries to do something very low-level but very necessary to
us. These low-level but necessary things include checking the well-formedness, validating the
document against its DTD or schema (just for validating parsers), resolving character reference,
understanding CDATA sections, and so on. XML parsers are just such "helper" programs and they
will do all these jobsl. With XML parsers, we are shielded from a lot of these complexicities and we
could concentrate ourselves on just programming at high-level through the API's implemented by the
parsers, and thus gain programming efficiency.

What is the difference between a DOMParser and a SAXParser?

DOM parsers and SAX parsers work in different ways.

* A DOM parser creates a tree structure in memory from the input document and then waits for
requests from client. But a SAX parser does not create any internal structure. Instead, it takes the
occurrences of components of a input document as events, and tells the client what it reads as it
reads through the input document.
* A DOM parser always serves the client application with the entire document no matter how
much is actually needed by the client. But a SAX parser serves the client application always only with
pieces of the document at any given time.
With DOM parser, method calls in client application have to be explicit and forms a kind of chain.

The DOM interface is perhaps the easiest to understand. It parses an entire XML document and
constructs a complete in-memory representation of the document using the classes modeling the
concepts found in the Document Object Model(DOM) Level 2 Core Specification.

The DOM parser is called a DocumentBuilder, as it builds an in-memory Document representation.

The javax.xml.parsers.DocumentBuilder is created by the
javax.xml.parsers.DocumentBuilderFactory. The DocumentBuilder creates an
org.w3c.dom.Document instance, which is a tree structure containing nodes in the XML Document.
Each tree node in the structure implements the org.w3c.dom.Node interface. There are many
different types of tree nodes, representing the type of data found in an XML document. The most
important node types are:

* element nodes that may have attributes

* text nodes representing the text found between the start and end tags of a document element.

Page 2 of 153
SAX interface

The SAX parser is called the SAXParser and is created by the javax.xml.parsers.SAXParserFactory.
Unlike the DOM parser, the SAX parser does not create an in-memory representation of the XML
document and so is faster and uses less memory. Instead, the SAX parser informs clients of the XML
document structure by invoking callbacks, that is, by invoking methods on a
org.xml.sax.helpers.DefaultHandler instance provided to the parser. This way of accessing document
is called Streaming XML.

The DefaultHandler class implements the ContentHandler, the ErrorHandler, the DTDHandler, and
the EntityResolver interfaces. Most clients will be interested in methods defined in the
ContentHandler interface that are called when the SAX parser encounters the corresponding
elements in the XML document. The most important methods in this interface are:

* startDocument() and endDocument() methods that are called at the start and end of a XML
document.
* startElement() and endElement() methods that are called at the start and end of an document
element.
* characters() method that is called with the text data contents contained between the start and
end tags of an XML document element.

Clients provide a subclass of the DefaultHandler that overrides these methods and processes the
data. This may involve storing the data into a database or writing it out to a stream.

During parsing, the parser may need to access external documents. It is possible to store a local
cache for frequently-used documents using an XML Catalog.

This was introduced with Java 1.3 in May 2000.

With SAX, some certain methods (usually over ridden by the client) will be invoked automatically
(implicitly) in a way which is called "callback" when some certain events occur. These methods do
not have to be called explicitly by the client, though we could call them explicitly.

Given the following XML document:

<?xml version="1.0" encoding="UTF-8"?>

<RootElement param="value">
<FirstElement>

Page 3 of 153
 Some Text
</FirstElement>
<?some_pi some_attr="some_value"?>
<SecondElement param2="something">
Pre-Text <Inline>Inlined text</Inline> Post-text.
</SecondElement>
</RootElement>

This XML document, when passed through a SAX parser, will generate a sequence of events like the
following:

* XML Element start, named RootElement, with an attribute param equal to "value"
* XML Element start, named FirstElement
* XML Text node, with data equal to "Some Text" (note: text processing, with regard to spaces,
can be changed)
* XML Element end, named FirstElement
* Processing Instruction event, with the target some_pi and data some_attr="some_value"
* XML Element start, named SecondElement, with an attribute param2 equal to "something"
* XML Text node, with data equal to "Pre-Text"
* XML Element start, named Inline
* XML Text node, with data equal to "Inlined text"
* XML Element end, named Inline
* XML Text node, with data equal to "Post-text."
* XML Element end, named SecondElement
* XML Element end, named RootElement

Note that the first line of the sample above is the XML Declaration and not a processing instruction;
as such it will not be reported as a processing instruction event.

The result above may vary: the SAX specification deliberately states that a given section of text may
be reported as multiple sequential text events. Thus in the example above, a SAX parser may
generate a different series of events, part of which might include:

* XML Element start, named FirstElement

* XML Text node, with data equal to "Some "
* XML Text node, with data equal to "Text"
* XML Element end, named FirstElement

Page 4 of 153
What's the difference between tree-based API and event-based API?

A tree-based API is centered around a tree structure and therefore provides interfaces on
components of a tree (which is a DOM document) such as Document interface,Node interface,
NodeList interface, Element interface, Attr interface and so on. By contrast, however, an event-based
API provides interfaces on handlers. There are four handler interfaces, ContentHandler interface,
DTDHandler interface, EntityResolver interface and ErrorHandler interface.

The main interface involved in SAX is a ContentHandler. You write your own class that implments
this interface. You supply methods to respond to events. One method is called when the document
starts, another when the document ends. One is called when an element starts, one when it ends.
Between these two there may be calls to a "characters" method if there are text character specified
between the start end end tags. If elements are nested, you may get two starts then two ends.

The entire procesing is up to you. The sequence follows the input source. If you don't care about a
specific element when it is processed, do nothing.

When the document end method is called, SAX is finished. Whatever you have kept in whatever
format is all that is kept.

This is in contrast to DOM which reads the entire input and constructs a tree of elements. Then the
tree represents entire source. You can move elements or attributes around to make a different file,
you can run it through a transformer. You can search it using XPath to find sequences of elements
or structures in the document and process them as you wish. When you are done, you can serialize
it (to produce an XML file, or an xml-format stream.

So, SAX is a Simple API for XML as its name implies. It does not have large demands for memory.
You can process a huge file and if you don't want to keep much data, or you are summing data from
the elements that go by, you will not require much memory. DOM builds a tree of Nodes to represent
the entire file. It takes more space to hold an element than it takes for the minimal character
representation -- "<a/>" 4 characters vs. dozens or hundreds.

Both will process the same input, and with SAX, you will see all input as it goes by. You may keep
what you want in whatever format you want. But, if you don't keep it, it is not stored somewhere for
you to process unless you run the input source through SAX again.

Page 5 of 153
Which one is better, SAX or DOM ?

Both SAX and DOM parser have their advantages and disadvantages. Which one is better should
depends on the characteristics of your application (please refer to some questions below).

Which parser can get better speed, DOM or SAX parsers?

SAX parser can get better speed.

In what cases, we prefer DOMParser to SAXParser?

In what cases, we prefer SAXParser to DOMParser?
What are some real world applications where using SAX parser is advantageous than using
DOM parser and vice versa?
What are the usual application for a DOM parser and for a SAX parser?

In the following cases, using SAX parser is advantageous than using DOM parser.

* The input document is too big for available memory (actually in this case SAX is your only
choice)
* You can process the document in small contiguous chunks of input. You do not need the
entire document before you can do useful work
* You just want to use the parser to extract the information of interest, and all your computation
will be completely based on the data structures created by yourself. Actually in most of our
applications, we create data structures of our own which are usually not as complicated as the DOM
tree. From this sense, I think, the chance of using a DOM parser is less than that of using a SAX
parser.
In the following cases, using DOM parser is advantageous than using SAX parser.
* Your application needs to access widely separately parts of the document at the same time.
* Your application may probably use a internal data structure which is almost as complicated
as the document itself.
* Your application has to modify the document repeatedly.
* Your application has to store the document for a significant amount of time through many
method calls.

Example (Use a DOM parser or a SAX parser?):

Assume that an instructor has an XML document containing all the personal information of the
students as well as the points his students made in his class, and he is now assigning final grades

Page 6 of 153
for the students using an application. What he wants to produce, is a list with the SSN and the grades.
Also we assume that in his application, the instructor use no data structure such as arrays to store
the student personal information and the points.

If the instructor decides to give A's to those who earned the class average or above, and give B's
to the others, then he'd better to use a DOM parser in his application. The reason is that he has no
way to know how much is the class average before the entire document gets processed. What he
probably need to do in his application, is first to look through all the students' points and compute the
average, and then look through the document again and assign the final grade to each student by
comparing the points he earned to the class average.

If, however, the instructor adopts such a grading policy that the students who got 90 points or
more, are assigned A's and the others are assigned B's, then probably he'd better use a SAX parser.
The reason is, to assign each student a final grade, he do not need to wait for the entire document to
be processed. He could immediately assign a grade to a student once the SAX parser reads the
grade of this student.

In the above analysis, we assumed that the instructor created no data structure of his own. What
if he creates his own data structure, such as an array of strings to store the SSN and an array of
integers to sto re the points ? In this case, I think SAX is a better choice, before this could save both
memory and time as well, yet get the job done.

Well, one more consideration on this example. What if what the instructor wants to do is not to
print a list, but to save the original document back with the grade of each student updated ? In this
case, a DOM parser should be a better choice no matter what grading policy he is adopting. He does
not need to create any data structure of his own. What he needs to do is to first modify the DOM tree
(i.e., set value to the 'grade' node) and then save the whole modified tree. If he choose to use a SAX
parser instead of a DOM parser, then in this case he has to create a data structure which is almost
as complicated as a DOM tree before he could get the job done.

How does the eventbased parser notice that there is an event happening, since these events
are not like click button or move the mouse?

Clicking a button or moving the mouse could be thought of as events, but events could be thought
of in a more general way. For example, in a switch statement of C, if the switched variable gets some
value, some 'case' will be taken and get executed. At this time, we may also say, one event has
occurred. A SAX parser reads the document character by character or token by token. Once some

Page 7 of 153
patterns (such as the start tag or end tag) are met, it thinks of the occurrences of these patterns as
events and invokes some certain methods overriden by the client.

To summarize all, lets discuss difference between both approach.

SAX Parser:
Event based model.
Serial access (flow of events).
Low memory usage (only events are generated).
To process parts of the document (catching relevant events).
To process the document only once.
Backward navigation is not possible as it sequentially processes the document.
Objects are to be created.
DOM Parser:
(Object based)Tree data structure.
Random access (in-memory data structure).
High memory usage (the document is loaded into memory).
To edit the document (processing the in-memory data structure).
To process multiple times (document loaded in memory).
Ease of navigation.
Stored as objects.

Page 8 of 153
Sample document for the example

<?xml version="1.0"?>
<!DOCTYPE shapes [
<!ELEMENT shapes (circle)*>
<!ELEMENT circle (x,y,radius)>
<!ELEMENT x (#PCDATA)>
<!ELEMENT y (#PCDATA)>
<!ELEMENT radius (#PCDATA)>
<!ATTLIST circle color CDATA #IMPLIED>
]>

<shapes>
<circle color="BLUE">
<x>20</x>
<y>20</y>
<radius>20</radius>
</circle>
<circle color="RED" >
<x>40</x>
<y>40</y>
<radius>20</radius>
</circle>
</shapes>

Page 9 of 153
Programs for the Example
program with DOMparser

import java.io.*;
import org.w3c.dom.*;
import org.apache.xerces.parsers.DOMParser;

public class shapes_DOM {

static int numberOfCircles = 0; // total number of circles seen
static int x[] = new int[1000]; // X-coordinates of the centers
static int y[] = new int[1000]; // Y-coordinates of the centers
static int r[] = new int[1000]; // radius of the circle
static String color[] = new String[1000]; // colors of the circles

public static void main(String[] args) {

try{
// create a DOMParser
DOMParser parser=new DOMParser();
parser.parse(args[0]);

// get the DOM Document object

Document doc=parser.getDocument();

// get all the circle nodes

NodeList nodelist = doc.getElementsByTagName("circle");
numberOfCircles = nodelist.getLength();

// retrieve all info about the circles

for(int i=0; i<nodelist.getLength(); i++) {

// get one circle node

Node node = nodelist.item(i);

// get the color attribute

NamedNodeMap attrs = node.getAttributes();
if(attrs.getLength() > 0)

Page 10 of 153
 color[i]=(String)attrs.getNamedItem("color").getNodeValue();

// get the child nodes of a circle node

NodeList childnodelist = node.getChildNodes();

// get the x and y value

for(int j=0; j<childnodelist.getLength(); j++) {
Node childnode = childnodelist.item(j);
Node textnode = childnode.getFirstChild();//the only text node
String childnodename=childnode.getNodeName();
if(childnodename.equals("x"))
x[i]= Integer.parseInt(textnode.getNodeValue().trim());
else if(childnodename.equals("y"))
y[i]= Integer.parseInt(textnode.getNodeValue().trim());
else if(childnodename.equals("radius"))
r[i]= Integer.parseInt(textnode.getNodeValue().trim());
}

// print the result

System.out.println("circles="+numberOfCircles);
for(int i=0;i<numberOfCircles;i++) {
String line="";
line=line+"(x="+x[i]+",y="+y[i]+",r="+r[i]+",color="+color[i]+")";
System.out.println(line);
}

} catch (Exception e) {e.printStackTrace(System.err);}

Page 11 of 153
program with SAXparser

import java.io.*;
import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;
import org.apache.xerces.parsers.SAXParser;

public class shapes_SAX extends DefaultHandler {

static int numberOfCircles = 0; // total number of circles seen

static int x[] = new int[1000]; // X-coordinates of the centers
static int y[] = new int[1000]; // Y-coordinates of the centers
static int r[] = new int[1000]; // radius of the circle
static String color[] = new String[1000]; // colors of the circles

static int flagX=0; //to remember what element has occurred

static int flagY=0; //to remember what element has occurred
static int flagR=0; //to remember what element has occurred

// main method
public static void main(String[] args) {
try{
shapes_SAX SAXHandler = new shapes_SAX (); // an instance of this class
SAXParser parser=new SAXParser(); // create a SAXParser object
parser.setContentHandler(SAXHandler); // register with the ContentHandler
parser.parse(args[0]);
} catch (Exception e) {e.printStackTrace(System.err);} // catch exeptions
}

// override the startElement() method

public void startElement(String uri, String localName,
String rawName, Attributes attributes) {
if(rawName.equals("circle")) // if a circle element is seen
color[numberOfCircles]=attributes.getValue("color"); // get the color attribute

else if(rawName.equals("x")) // if a x element is seen set the flag as 1

flagX=1;

Page 12 of 153
 else if(rawName.equals("y")) // if a y element is seen set the flag as 2
flagY=1;
else if(rawName.equals("radius")) // if a radius element is seen set the flag as 3
flagR=1;
}

// override the endElement() method

public void endElement(String uri, String localName, String rawName) {
// in this example we do not need to do anything else here
if(rawName.equals("circle")) // if a circle element is ended
numberOfCircles += 1; // increment the counter
}

// override the characters() method

public void characters(char characters[], int start, int length) {
String characterData =
(new String(characters,start,length)).trim(); // get the text

if(flagX==1) { // indicate this text is for <x> element

x[numberOfCircles] = Integer.parseInt(characterData);
flagX=0;
}
else if(flagY==1) { // indicate this text is for <y> element
y[numberOfCircles] = Integer.parseInt(characterData);
flagY=0;
}
else if(flagR==1) { // indicate this text is for <radius> element
r[numberOfCircles] = Integer.parseInt(characterData);
flagR=0;
}
}

// override the endDocument() method

public void endDocument() {
// when the end of document is seen, just print the circle info
System.out.println("circles="+numberOfCircles);
for(int i=0;i<numberOfCircles;i++) {
String line="";

Page 13 of 153
 line=line+"(x="+x[i]+",y="+y[i]+",r="+r[i]+",color="+color[i]+")";
System.out.println(line);
}
}

Page 14 of 153
DOM versus SAX parsing:
Practical differences are the following

1. DOM APIs map the XML document into an internal tree structure and allows you to refer to the
nodes and the elements in any way you want and as many times as you want. This usually means
less programming and planning ahead but also means bad performance in terms of memory or CPU
cycles.
2. SAX APIs on the other hand are event based ie they traverse the XML document and allows
you to trap the events as it passes through the document. You can trap start of the document, start
of an element and the start of any characters within an element. This usually means more
programming and planning on your part but is compensated by the fact that it will take less memory
and less CPU cycles.
3. DOM performance may not be an issue if it used in a batch environment because the
performance impact will be felt once and may be negligible compared to the rest of the batch process.
4. DOM performance may become an issue in an on line transaction processing environment
because the performance impact will be felt for each and every transaction. It may not be negligible
compared to the rest of the on line processing, since by nature they are short living process.
5. Elapsed time difference in DOM vs SAX

Page 15 of 153
A XML document 13kb long with 2354 elements or tags. This message represents an
accounting G/L entries sent from one Banking system to another.

Windows 2000 running in Pentium

SAX version - 1 sec
DOM version - 4 secs

IBM mainframe under CICS 1.3

SAX version- 2 secs
DOM version 10 secs

IBM mainframe under CICS 2.2

SAX version- 1 sec
DOM version 2 secs

The significant reduction in under CICS2.2 is due to the fact that the JVM is reusable and it uses
jdk1.3 vs jdk1.1

Page 16 of 153
Introduction EAI Tools
Introduction to SAP Net Weaver 7.1
Modules of SAP Net Weaver 7.1
Overview SAP Process Integration 7.1
Architecture of SAP PI 7.1

Page 17 of 153
Page 18 of 153
Page 19 of 153
Page 20 of 153
Page 21 of 153
Page 22 of 153
Page 23 of 153
Page 24 of 153
Page 25 of 153
Page 26 of 153
Page 27 of 153
Page 28 of 153
System Landscape Directory
Software Catalog
Product and Product Versions
Software Unit
Software Component and its versions

System Catalog
Technical Systems
Business Systems

Page 29 of 153
Page 30 of 153
Page 31 of 153
Page 32 of 153
Page 33 of 153
Page 34 of 153
Page 35 of 153
Page 36 of 153
Page 37 of 153
Integration Builder:

Integration Repository
Importing Software Component Versions
Integration Scenario & Integration Process
Integration Scenario
Actions
Integration Process

Interface Objects
Message Interface (ABAP and Java Proxies)
Message Type
Data Type
Data Type Enhancement
Context Object
External Definition

Mapping Objects
Message Mapping (Graphical Mapping including UDFs)
ABAP Mapping
JAVA Mapping
Interface Mapping

Adapter Objects
Adapter Metadata
Communication Channel Template

Imported Objects
RFCs
IDOCs

Page 38 of 153
Page 39 of 153
Page 40 of 153
Page 41 of 153
Page 42 of 153
What is ESR?

The ES Repository is really the master data repository of service objects for Enterprise SOA
􀂄 What do we mean by a design time repository?
􀂄 This refers to the process of designing services
􀂄 And the ES Repository supports the whole process around contract first or the well known
outside in way of developing services
􀂄 It provides you with a central modeling and design environment which provides you with all the
tools and editors that enable you to go through this process of service definition
􀂄 It provides you with the infrastructure to store, manage and version service metadata
􀂄 Besides service definition, the ES Repository also provides you with a central point for finding
and managing service metadata from different sources

Page 43 of 153
How has ESR Evolved?

What can ESR be used for?

The first version of the ES Repository for customers will be the PI based Integration Repository
which is already part of SAP XI 3.0 and SAP NetWeaver 2004s
􀂄 Customers can be assured that their investments in the Repository are protected because there
will be an upgrade possibility from the existing repository to the Enterprise Services Repository
􀂄 The ES Repository is of course enhanced with new objects that are needed for defining SAP
process component modeling methodology
􀂄 The ES Repository in the new release will be available with SAP NetWeaver Process Integration
7.1 and probably also with CE available in the same time frame
􀂄 The ES Repository is open for customers to create their own objects and extend SAP delivered
objects

Page 44 of 153
DATA Types in 3.0 / 7.0

What is a Data Type?

It is the most basic element that is used in design activities – you can think of them as
variables that we create in programming languages.

Page 45 of 153
What is a Message Type?

Page 46 of 153
Data Types in 7.1 have changed / evolved from 7.0 – the following sections illustrate this.

Page 47 of 153
Basic Rules of creating Data Types

Page 48 of 153
Page 49 of 153
What are Data Type Enhancements? What are they used for?

Page 50 of 153
Message Interface in 3.0 / 7.0 -> these have evolved to Service Interface in 7.1

Page 51 of 153
Page 52 of 153
Page 53 of 153
Page 54 of 153
How Service Interface in 7.1 has evolved from Message Interface in 3.0 / 7.0

Page 55 of 153
Page 56 of 153
Page 57 of 153
Page 58 of 153
Page 59 of 153
Page 60 of 153
Page 61 of 153
Interface Mapping in 3.0 / 7.0 has changed to Operations Mapping in 7.1

Why do we need Interface Mapping / Operations Mapping ?

Page 62 of 153
Page 63 of 153
What does an Integration Scenario do?

Page 64 of 153
Page 65 of 153
BPM or Integration Process

Page 66 of 153
Page 67 of 153
Page 68 of 153
Page 69 of 153
Integration Builder:
Integration Directory
Creating Configuration Scenario
Party
Service without Party
Business System
Communication Channels
Business Service
Integration Process

Receiver Determination
Interface Determination
Sender Agreements
Receiver Agreements

Page 70 of 153
Page 71 of 153
Page 72 of 153
Page 73 of 153
Page 74 of 153
Page 75 of 153
Page 76 of 153
Adapter Communication
Introduction to Adapters
Need of Adapters
Types and elaboration on various Adapters
1. FILE
2. SOAP
3. JDBC
4. IDOC
5. RFC
6. XI (Proxy Communication)
7. HTTP
8. Mail
9. CIDX
10. RNIF
11. BC
12. Market Place

Page 77 of 153
Page 78 of 153
Page 79 of 153
Page 80 of 153
Page 81 of 153
Page 82 of 153
Page 83 of 153
Page 84 of 153
Page 85 of 153
Page 86 of 153
RECEIVER IDOC ADAPTER

Page 87 of 153
Page 88 of 153
Page 89 of 153
Page 90 of 153
Page 91 of 153
Page 92 of 153
Page 93 of 153
Page 94 of 153
Page 95 of 153
Page 96 of 153
Page 97 of 153
Page 98 of 153
Page 99 of 153
Page 100 of 153
Page 101 of 153
Page 102 of 153
Page 103 of 153
Page 104 of 153
Page 105 of 153
Page 106 of 153
Page 107 of 153
Page 108 of 153
Page 109 of 153
Page 110 of 153
Page 111 of 153
Page 112 of 153
Page 113 of 153
Page 114 of 153
PROXIES

Page 115 of 153

Runtime Workbench

Cache Overview
Message Display Tool
Test Tool
Message Monitoring
Component Monitoring
End to End Monitoring

Page 116 of 153

Page 117 of 153
Page 118 of 153
Page 119 of 153
Page 120 of 153
New features in SAP PI (Process Integration) 7.1
1. Enterprise service repository
2. Service Bus
3. Service Registry
4. Web Service Publishing
5. Service Interface
6. Folders in the Integration Builder
7. Advanced Adapter Engine
8. Reusable UDFs in Function Library
9. RFC and JDBC Lookup using graphical methods
10. Importing of Database SQL Structures
11. Service Runtime for Web Services
12. Graphical Variables
13. WS Adapter and MDM Adapter
14. Integrated Configuration
15. Direct Connection Methods
16. Stepgroup and User Decision step in BPM
17. eSOA Manager Architecture

Page 121 of 153

Highlights include:

􀂄 The Enterprise Services Repository containing the design time ES Repository and the
UDDI Services Registry.

Page 122 of 153

􀂄 SAP NetWeaver Process Integration 7.1 includes significant performance enhancements.
In particular, high-volume message
processing is supported by message packaging where a bulk of messages are processed in
a single service call.

􀂄 Additional functional enhancements, such as principle propagation based on open standards

SAML, allows you to forward user
credentials from the sender to the receiver system.
􀂄 Also, XML schema validation, which allows you to validate the structure of a message payload
against an XML schema.
􀂄 Also, importantly support for asynchronous messaging based on the Web Services Standard
Web Services Reliable Messaging
(WS-RM) for both brokered communication and for point-to-point communication between two
systems will be supported in this
release.
􀂄 Besides that, a lot of SOA enabling standards or WS standards are supported as part of this
release again making it the core
technology enabler of Enterprise SOA
􀂄 The new SAP NetWeaver Process Integration release includes major enhancements to the BPM
offering as:

􀂄 Improved performance of the runtime (Process Engine) - Message packaging, process

queuing, transactional
handling (logical units of work of process blocks and singular process steps - flexible hibernation)

􀂄 WS-BPEL 2.0 preview

􀂄 Further enhancements: Modeling enhancements such as, e.g., step groups, BAM patterns;
configurable
parameters; embedded alert management (alert categories within the BPEL process definition;
human interaction
(generic user decision), task and workflow services for S2H scenarios (aligned with BPEL4People)
􀂄 The process integration capability includes the integration server with the infrastructure services
provided by the underlying
application server
􀂄 The process integration capability within SAP NetWeaver is really laying the foundation for SOA
􀂄 Standards compliant offering enterprise class integration capabilities, guaranteed delivery and
quality of service

A lot of great new functionalities are provided with SAP NetWeaver Process Integration 7.1,
but all are extensions of the robust architecture based on JEE5. And JEE5 promotes less
memory consumption and easier installation

􀂄 The process integration capabilities within SAP NetWeaver offer the most common ESB
components like
􀂄 Communication infrastructure (messaging and connectivity)
􀂄 Request routing and version resolution
􀂄 Transformation and mapping
􀂄 Service orchestration
􀂄 Process and transaction management
􀂄 Security
􀂄 Quality of service
􀂄 Services registry and metadata management
􀂄 Monitoring and management
􀂄 Support of Standards (WS RM, WS Security, SAML, BPEL, UDDI, etc.)
􀂄 Distributed deployment and execution
􀂄 Publish Subscribe (not covered today)

Page 123 of 153

􀂄 These ESB components are not packaged as a standalone product from SAP but as a set of
capabilities. Customers using the process integration functionality can leverage all or parts of these
capabilities.
􀂄 More aspects to consider:
􀂄 SAP Java EE5 engine as runtime environment, but no development tools provided
􀂄 Local event infrastructure provided in SAP systems
􀂄 WS Security: The main update is the support of SAML for the credential propagation.
Furthermore, with WS-RM authentication
via X.509 certificates as well as encryption are also supported.
􀂄 WS Policy: W3C WS Policy 1.2 - Framework (WS-Policy) and Attachment (WS-
PolicyAttachment) are supported.

􀂄 To summarize these two slides, the main message is that the most important reasons to
use the benefits of the SAP NetWeaver PI
7.1 release are:

􀂄 Use Process Integration as an SOA backbone

􀂄 Establish ES Repository as the central SOA repository in customer landscapes
􀂄 Leverage support of additional WS standards like UDDI, WS-BPEL and tasks, WS-RM etc.
􀂄 Enable high volume and mission critical integration scenarios
􀂄 Benefit from new functionalities like principal propagation, XML payload validation and BAM
capabilities

Page 124 of 153

PI 7.3 Delta Overview

Page 125 of 153

Page 126 of 153
Page 127 of 153
Page 128 of 153
Page 129 of 153
Page 130 of 153
Page 131 of 153
Page 132 of 153
Page 133 of 153
Page 134 of 153
Page 135 of 153
Page 136 of 153
Page 137 of 153
Page 138 of 153
Page 139 of 153
USER ACCESS AND AUTH IN 7.3

Page 140 of 153

Page 141 of 153
Page 142 of 153
Page 143 of 153
Page 144 of 153
Page 145 of 153
Page 146 of 153
Page 147 of 153
Page 148 of 153
Page 149 of 153
Page 150 of 153
Page 151 of 153
Page 152 of 153
XI Architecture – The Complete Picture

Page 153 of 153