Está en la página 1de 153


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 The is created DocumentBuilder by creates the 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













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 eventbased 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.

Page 7 of 153

Once some 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*; 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


// 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*; 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; static int flagY=0; static int flagR=0;

//to remember what element has occurred //to remember what element has occurred //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(); parser.setContentHandler(SAXHandler); parser.parse(args[0]); } catch (Exception e) {e.printStackTrace(System.err);} // catch exeptions } // create a SAXParser object // register with the ContentHandler

// 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")) flagX=1;

// if a x element is seen set the flag as 1

Page 12 of 153

else if(rawName.equals("y")) flagY=1;

// if a y element is seen set the flag as 2

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")) numberOfCircles += 1; } // if a circle element is ended // 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 versionDOM version 2 secs 10 secs

IBM mainframe under CICS 2.2 SAX versionDOM version 1 sec 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


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


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. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. Enterprise service repository Service Bus Service Registry Web Service Publishing Service Interface Folders in the Integration Builder Advanced Adapter Engine Reusable UDFs in Function Library RFC and JDBC Lookup using graphical methods Importing of Database SQL Structures Service Runtime for Web Services Graphical Variables WS Adapter and MDM Adapter Integrated Configuration Direct Connection Methods Stepgroup and User Decision step in BPM 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.

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 (WSPolicyAttachment) 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


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