SAP Library - SAP NetWeaver Composition Environment Library

SAP NetWeaver Composition Environment Library

What's New in SAP NetWeaver Composition Environment 7.2

Administrator's Guide

Architecture of AS Java

Configuration of SAP NetWeaver CE

Administration of SAP NetWeaver CE

SAP NetWeaver CE Security Guide

Developer's Guide

Guidelines for Developing Composite Applications

Composite Application Layers

Prerequisites

Set Up Your Development System

Set Up Your Development Project for the Composite Application

Model Business Processes

Find and Validate Enterprise Services for Reuse

Develop User Interfaces for the BPM Layer

Integrate Online Interactive Forms by Adobe (Optional)

Adapt, Simplify and Join Existing Services using Service Compose

Provide New Data Objects (Optional)

Develop and Expose New Business Logic

Assemble and Configure Process Execution

Integrating Applications into the Portal

SAP NetWeaver - Demo Model

SAP NetWeaver Developer Studio Basics

Starting the Developer Studio

Setting Workspace Using the -data Parameter

Setting the Java VM Using the -vm Parameter

Changing the Default Workspace

Starting the Developer Studio Using a Batch File

Using Other Start Parameters

Updating the Developer Studio

Viewing the Error Log File

Working with the Developer Studio

SAP's Component Model

Creating and Modifying Projects

Using Different Java Runtime Environment Versions

Referencing Libraries

Testing Java Applications with JLin

Creating and Editing Variants

Executing JLin Tests

Displaying JLin Results

Executing JLinEE Tests

Testing Web Dynpro Applications

Test Scripts and Test Results

Recording a Test Script in the Developer Studio

Replaying a Test Script in the Developer Studio

Comparing Scripts and Results

Creating and Maintaining Update Site Mirrors

Administering AS Java from the Developer Studio

Starting and Stopping SAP Systems

Viewing the Communication Ports

Monitoring the Application Server with the SAP MC

Starting and Stopping Components

Enabling and Disabling the Debug Mode

Viewing Log and Trace Files

Changing Log Configuration

Record Issues with the Support Session

Create and Examine Snapshots

Reference

Layout of the SAP MC

Context Menus and Settings of the SAP MC

Administration Using Telnet

Generating Applications Based On Predefined Templates

Development Infrastructure

Maintaining Composite Applications Using the Composite Designer

Concepts

Tasks

Importing and Exporting Existing Composite Applications

Creating Composite Applications

Creating New Development Objects

Managing Relations

Configuring Composite Designer in the Developer Studio

Customizing Applications with the Extensibility Configuration Fr

Concepts of Extensibility Configuration Framework

Creating Extension Points

Creating Extensions

Activating and Deactivating Extensions

Reviewing the Available Extension Points and Extensions on AS Ja

Modeling Processes with Process Composer

Getting Started

Modeling My First Process

Modeling the Process

Creating a Project

Creating a Process

Creating Flow Objects

Creating Artifacts

Creating Flow Controls

Defining Business Logic

Importing and Assigning Service Interface Definitions

Creating and Assigning Tasks

Importing and Assigning Data Types

Building and Deploying the Business Process Model

Concepts

Processes

Synchronous and Asynchronous Processes

Two Perspectives Approach

Projects and Processes in the Process Composer

Granularity of a Process Model

Process Roles

Process Context

Process Modeling Approaches

Top-Down Approach

Bottom-Up Approach

Inside-Out Approach

Using BPMN Process Models

Consuming User Interfaces in Processes

Using Adobe Offline Forms

Tasks

Creating a Project

Creating a Process

Working with BPMN 2.0 Compliant Files

Modeling Sub-Processes

Modeling Referenced Sub-Processes

Modeling Embedded Sub-Processes

Process and Sub-Process Versioning

Defining Process Participants Using Pools

Defining Pool User Texts

Defining Roles in the Process Using Lanes

Defining Task Owners

Defining Potential Owners

Defining Excluded Owners

Modeling Events

Correlation for Intermediate Message Events

Creating Reusable Event Triggers

Importing Service Interface Definitions

Creating Service Interface Definitions

Modeling Automated Activities

Configuring WSDL and XSD Reimport Preferences

Importing Service Interface Definitions

Creating Service Interface Definitions

Working with Service Groups

Modeling Human Activities

Overriding Task Attributes for an Individual Human Activity

Defining Task Owners

Defining Potential Owners

Defining Excluded Owners

Working with Tasks

Preparing Web Dynpro DC to be used in BPM

Supported Data Types and Limitations for Web Dynpro in BPM

Assigning a User Interface to a Task

Generating Tasks and UI Components with UI Task Generation Templ

Generating a UI Component for a Single Task

Troubleshooting on Web Dynpro Components in BPM

Designing, Storing and Assigning an Offline Form to a Task

Designing an Offline Form

Storing an Offline Form in the ECM Repository

Assigning an Offline Form to a Task

Defining Task Owners

Defining Potential Owners

Defining Excluded Owners

Defining Task Administrators

Defining Time Constraints of a Task

Defining an Activation Time of a Task

Defining a Default Start Deadline of a Task

Defining a Default Completion Deadline of a Task

Defining a Default Expiration Time of a Task

Transforming Complex Data to Simple Data with Mapping Activities

Modeling Multi-Instance Loops of Activities

Modeling Notifications

Controlling the Process Flow with Gateways

Creating Data Objects

Importing XSD files

Creating and Editing XSD Files

Defining Input and Output Mapping

Using Annotations in the Process Model

Connecting Flow Objects in a Process

Connecting Separate Process Participants with Message Flow

Modeling Exceptions and Exceptions Handling

Creating a Flow Ruleset

Using Versions of a Ruleset in a Process

Formatting the Process Model

Translating Language-Specific Attributes in BPM

Building and Deploying a Process

Starting a Process

Performing Process Analytics

Configuring BPM-BW Connectivity

Extracting Data to SAP NetWeaver Business Warehouse

Reporting on Process Context Data

Creating and Editing Reporting Data Sources

Modeling Reporting Activities

Real-Time Reporting with Visual Composer

Business Log DataSource

My Processes DataSource

My Tasks DataSource

Principal Assignment DataSource

Debugging Processes

Managing the Debugged Process

Debugging Processes in the Process Instances View

Reference

Modeling Your Business Process

Tips and Tricks

Accelerated Modeling with Speed Buttons

Modeling Defaults and Specials

Quick and Easy Mapping

Copying and Pasting Objects in the Process Model

Undoing Process Modeling Steps

Modeling Rules with Rules Composer

What's New in the Rules Composer

Getting Started

The Rules Composer Interface

Typical Workflow

Quick Start Tutorial

Writing Rules on XML Schema

Creating the Rules Composer DC

Creating the XML Schema

Creating the Ruleset

Creating the Decision Table

Creating the Rule

Deploying the Rules

Executing the Rules

Writing Rules on Java Classes

Creating the Rules Composer DC

Creating and Testing Rules in a Flow Ruleset

Creating the Rules Composer DC

Creating the XML Schema

Creating the Definition

Creating the Enumeration Type

Creating the Flow Ruleset

Creating the Decision Tables

Creating the Rule Scripts

Creating the Rule Flow

Creating and Running the Test Case

Exposing the Flow Ruleset as a Web Service

Evaluate Decision Table Action

Dynamic Invocation of a Decision Table

Rule Flow

Rule Script

Exclusive Choice Gateway

Execute Ruleset Action

Break and Continue Actions

Handling Exceptions

Rules Testing

Tasks

Creating and Configuring a Rules Composer DC

Creating a Rules Composer DC

Deleting a Rules Composer DC

Creating and Editing a Definition

Creating a Definition

Creating a Common Definition

Deleting a Definition

Using Project Resources

Locating the Project Resources Node

Creating and Editing an Enumeration Type

Creating an Enumeration Type

Editing an Enumeration Type

Updating Aliases to Use an Enumeration Type

Updating a Definition to Use an Enumeration Type

Using an Enumeration Type

Deleting an Enumeration Type

Creating and Editing an Effectivity

Creating an Effectivity

Editing an Effectivity

Assigning an Effectivity to an If-Then Rule

Deleting an Effectivity

Creating a Definition Alias

Replacing Aliases

Setting Smart Aliases

Creating and Editing an If-Then Rule

Creating an If-Then Rule

Adding a Condition

List of Return Types and Comparator Choices for Conditions

Adding a Nested Condition

Adding an Action

Deleting Conditions and Actions

Adding a Precondition

Setting a Rule Priority

Overriding an If-Then Rule

Copying an If-Then Rule

Renaming an If-Then Rule

Deleting an If-Then Rule

Creating and Editing a Decision Table

Creating a Decision Table

Adding a Condition

Adding an Other Condition

Adding Condition and Action Values

List of Comparator Choices for a Decision Table

Using a Decision Table in a Rule

Setting Decision Table Properties

Changing the Layout of a Decision Table

Exporting Data from a Decision Table to an Excel Sheet

Importing Data from an Excel Sheet to a Decision Table

Copying a Decision Table

Renaming a Decision Table

Deleting a Decision Table

Creating a Flow Ruleset

Locating the Flow Ruleset

Creating and Editing a Rule Flow

Creating a Rule Flow

Working with the Rule Flow Editor

Converting a Rule Flow to a Main Flow

Copying a Rule Flow

Renaming a Rule Flow

Deleting a Rule Flow

Creating and Editing a Rule Script

Creating a Rule Script

Adding an Action in a Rule Script

Renaming a Rule Script

Copying a Rule Script

Deleting a Rule Script

Creating and Editing an Exclusive Choice Gateway

Viewing Usage of Aliases

Creating and Editing Complex Expressions

Generating a Report

Comparing Aliases and Ruleset

Validating Rules

Testing Rules

Locating the Test Cases Node

Creating and Running a Test Scenario

Creating and Running a Test Case

Deploying Rules

Executing Rules

Looking Up the Rule Engine

Exposing a Ruleset as a Web Service

Invoking a Ruleset

Rules on XML

Configuring Rule Engine Parameters

Archiving Business Rules Logs

Viewing Rules Log Information

Working with the Rules Manager

Getting Started

Understanding the Rules Manager User Interface

Setting Access Control for Business Rules Project

Setting Authorizations in Business Rules Management

Setting a Role to Approve a Ruleset

Logging into the Rules Manager

Tasks

Opening a Project

Changing a Project

Creating and Editing a Definition

Adding a Definition

Duplicating a Definition

Renaming a Definition

Deleting a Definition

Viewing Definitions Usage

Converting Fixed Definition to Variable Definition

Adding and Editing Values for Enumeration Type

Adding Values for Enumeration Type

Editing Values for Enumeration Type

Deleting Values for Enumeration Type

Creating and Editing a Ruleset

Creating a Ruleset

Opening a Ruleset

Duplicating a Ruleset

Renaming a Ruleset

Deleting a Ruleset

Working with a Flow Ruleset

Opening a Flow Ruleset

Opening a Rule Flow

Opening a Rule Script

Viewing Gateway

Viewing Flow as Diagram

Creating and Editing a Rule

Opening a Rule

Creating a Rule

Changing Rule Priority

Changing Rule Status

Changing Date Effectivity

Adding a Condition

Adding Nested Conditions

Deleting a Condition

Adding an Action

Deleting an Action

Arranging Conditions and Actions

Adding a Precondition

Adding Overrides in a Rule

Creating and Editing a Decision Table

Creating a Decision Table

Adding a Condition in a Decision Table

Renaming an Other Condition in a Decision Table

Changing a Condition in a Decision Table

Removing a Condition in a Decision Table

Adding an Action in a Decision Table

Changing an Action in a Decision Table

Removing an Action in a Decision Table

Adding Condition and Action Values

Using a Decision Table in a Rule

Changing the Layout of the Decision Table

Duplicating a Decision Table

Renaming a Decision Table

Deleting a Decision Table

Creating Complex Expressions

Uploading Changes

Testing Rules

Using the Search Utility

Viewing Version History

Comparing Versions

Viewing Report

Running Consistency Checks

Importing an Updated Project into the Rules Composer

Designing Composite Processes with Guided Procedures

Getting Started

Setting Up Portal Roles

Getting Started with Guided Procedures Design Time

Launching Guided Procedures (GP) Design Time

Gallery

Managing Folders and Objects in the Gallery

Copying GP Content

Object Design Time

Getting Started with Guided Procedures Runtime

Getting Familiar with the GP Runtime

Core Elements of the Runtime

Getting Familiar with the GP Runtime Work Center

GP Generic Views

Getting Familiar with the Process Instance Work Center

Process Instance Generic Views

Other Elements

Concepts

Guided Procedures Architecture Overview

Process Roles

Callable Object

Callable Object Parameters

Process Modeling

Tasks

Exposing Applications as Callable Objects

Creating Callable Objects in the GP Design Time

Exposing Web Dynpros as Callable Objects

Creating Web Dynpro Form Callable Objects

Exposing WD4VC Applications as Callable Objects

Exposing Web Services as Callable Objects

Exposing RFCs as Callable Objects

Exposing BSPs as Callable Objects

Creating Portal Callable Objects

Exposing Web Pages as Callable Objects

Creating Callable Objects for Background Execution

Creating Business Logic Callable Objects

Creating Content Packages

Creating Decision Dialogs

Creating Object Views

Creating Pass Through Form Callable Objects

Predefined Callable Objects

Testing Callable Objects

Checking Callable Object Consistency

Modeling and Configuring Workflows

Action Design

Creating Actions

Attaching Callable Objects

Ad-Hoc Items

Customizing Titles of Tasks

Block Design

Creating Blocks

Defining Block Flow

Configuring Exception Handling

Parallel Dynamic Block

Process Design

Creating Process Templates

Customizing a Process Instance Title

Defining Process Flow

Configuring Process Roles

Defining Restrictions

Defining Runtime Views

Configuring Process Control Items

Composite Forms

Configuring Process Instantiation

Searching in the Parameter List

Configuring Parameters

Consolidating Parameters

Consolidating Roles

Granting Permissions

Granting View Permissions

Defining and Configuring Notifications

Attachments

Info Callable Objects

Integrating Offline and Form-Based Activities

Concepts of the Composite Forms in Guided Procedures

Guided Procedures Forms Use Types

Form Context

Logical Criteria

Creating and Configuring Forms

Enabling Form Submission Using HTTP

Enabling Form Submission Using SMTP

Creating Logical Criteria

Creating Form Objects in the GP Design Time

Building and Using a Form Context

Enabling Form Input Validation

Configuring Post-Processing Services

Adding Content to Field-Based Templates

Adding Content to Schema-Based Templates

Configuring Form Use and Data Processing Options

Designing Dynamic Forms

Exposing Composite Forms as Callable Objects

Using a Display Callable Object for Forms

Instantiating and Testing Guided Procedure Forms

Activating and Maintaining Guided Procedures Content

Activating Guided Procedures Content

Comparing and Restoring Object Versions

Customizing and Updating SAP Content

Managing GP Content Using the Developer Studio

Starting and Terminating Processes Within a Composite

Starting (Initiating) a New Process

Granting Substitution Permissions

Consuming the GPProcessDiscovery Web Services

Starting a Process Using Web Services

Completing Actions Within a Composite

Consuming the GPActionDiscoveryWSIL Web Service

Completing a Step Using Web Services

Using the GP APIs

Setting Up Your Project

Implementing and Registering Callable Object Types

Implementing the Design Time for a New Callable Object Type

Implementing the Runtime for a New Callable Object Type

Registering a New Callable Object Type

Implementing Additional Callable Objects

Implementing Web Dynpro Callable Objects

Implementing Callable Objects for Background Execution

Implementing BSP Callable Objects

Modeling and Configuring Workflows Using the GP API

Instantiating the Design Time Manager

Creating GP Development Objects

Creating Callable Objects

Implementing Exception Handling

Implementing Parameter Mapping

Defining Activity Mappings

Defining Callable Object Mappings

Implementing Role Consolidation

Editing GP Development Objects

Deleting GP Development Objects

Exposing Business Object Data in the GP Context

Constructing a KM Document Template and Provider

Including Additional Functionality

Using the Forms API

Accessing the Forms Java API

Retrieving Process Template Details

Creating Form Instances

Creating Custom Runtime Views Using the GP API

Runtime View Component Interfaces

Interface Methods for Component Initialization

Registering Web Dynpro Components and Runtime Views

Registering Runtime Views Using Servlets

Scheduling Process Initiation Using the GP API

Implementing a Post-Processing Class with Callback

Starting and Terminating Processes Using the GP API

Managing Runtime Activities Using the GP API

Completing Actions Using the GP API

Managing Process Notifications Using the GP API

Retrieving Process Notification Instances

Updating Notification Processing Time and Status

Creating Deadlines and Durations

Managing Runtime Attachments Using the GP API

Attachment Attributes

Reference

Tutorials

Developing Your First Process

Creating a Folder

Creating an HTML Start Page

Creating an Input Data Form

Setting Up Mail Templates

Replacements

Creating an Approval Callable Object

Creating a Simple Process

Initiating a Process

Exposing an RFC-Enabled Function Module as a Callable Object

Configuring an RFC Destination

Importing a BAPI in Guided Procedures

Testing and Activating an RFC Callable Object

Importing a Web Service in Guided Procedures

Testing and Activating a Web Service Callable Object

Developing Your First Composite Form Process

Modeling the Composite Form Activity

Configuring Pre-Filling Services

Creating the Composite Form

Designing the Form Template Layout

Exposing the Composite Form as a Callable Object

Modeling the Form Approval Activity

Modeling the Notification Activity

Creating Notification E-Mail Templates

Designing the Process Template

Implementing and Exposing a Web Dynpro as a Callable Object

Creating and Configuring the Web Dynpro Project

Implementing a Web Dynpro Component

Creating an Instance of the Callable Object

Testing and Activating the Callable Object

Implementing and Exposing a Background Callable Object

Creating a Java Development Component

Implementing a Background Callable Object

UserDetailsCallableObject

Creating and Deploying a Java Enterprise Application

Exposing a Java Class as a Callable Object

Testing and Activating the Background Callable Object

Configuring Exception Handling

Creating a Data Input Form

Creating an Action to Handle the Exception

Creating a Data Display Form

Creating an Exception Block

Creating an Exception Process

Implementing a BSP Callable Object

Sample BSP Application

Creating a Start Page

Creating a Completion Page

Creating an Instance of a BSP Callable Object

Scenario: Order Office Material

Web Dynpro Component Implementation

WDCODisplaySelectItems

WDCOSelectedItems

WDCOOrderItems

WDCOApproveItems

Defining Fine-Grained Process Components

Decision List or Order Number

Display List and Select

Decision Order Another Item

Display Selected Items

Order Items

Approve Items

Send Order Confirmation

Order Confirmation

E-Catalog

Defining Blocks

Display List and Select Loop Body

Display List and Select Loop

Order with Order Number

Order From List

Order Office Material

Process Definition: Putting It All Together

Providing, Discovering and Consuming Services

Developing Java Web Dynpro Applications

Reference

UI Element Guide

Common UI Element Properties

WDTableCellDesign

Specifying the Image Source

WDHotkey

Choosing the Layout

ColumnLayout

ColumnLayoutData and ColumnLayoutHeadData

MatrixData and MatrixHeadData

RowLayout API

RowData and RowHeadData

Defining PageLayout

Implementing Drag and Drop

DragSourceInfo

DropTarget

DropTargetInfo and DropOnRowTargetInfo

FileDropTarget

Specifying Drop Targets at Row Level

MultipleAccordionItem

AnalyticsChart

BIApplicationFrame: Integrating BEx Web Applications

BIMethods API: Access to Actions of a BEx Web Application

Breadcrumb Navigation

BreadCrumb

BreadCrumbStep

MultipleBreadCrumbStep API

HierarchicalCalendarMonthView

DateNavigatorLegend API

DropDownByIndex

DropDownByKey

Explanation

FileUpload and FileDownload: Data Transfer

FileUpload

FileDownload

Binding resource Property

Loading the InputStream at FileDownload on Demand

FlashIsland

Implementing Adobe Flash Islands for Web Dynpro Java

Converting a Web Dynpro View to a Flash View

Displaying and Editing Formatted Text

Supported XHTML Tags for FormattedText

FormattedTextEdit

FormattedTextView

SimpleFormattedTextField

Implementing a SimpleFormattedTextField

Creating Formatted Text

Gantt

GeoMap

Code Example of the Use of a Geographical Map

Example for Displaying a Route

Implementing a Combo Box

Enabling AutoComplete for InputFields

MultipleLegendItem API

Implementing Menus: ContextMenu, MenuBar and PopupMenu

Utilizing ContextMenus

Implementing IWDIOSFactory

HorizontalContextualPanel

PatternExpandFunction

RadioButtonGroupByKey

RadioButtonGroupByIndex

Integration Points for Silverlight

Splitter

Implementing Tables

Table Structure

Table Properties and Events

Filtering and Sorting in a Table

TableColumnGroup

TableColumn

TableScrollTipProvider

TableRowGrouping

TreeByNestingTableColumn

TableStandardCell

TableSingleMarkableCell

TablePopin

TablePopinToggleCell

TextBar

TableSelectionMenuConfiguration

Implementing TableRowGrouping

Adding New Rows

Defining Cell Variants Using the Example TableStandardCell

Implementing Scroll Tips

ToolBarDropDownByIndex

Data Binding of a Tree UI Element

Code Example for Creation of a Tree UI Element

Controller/Context Editor

Working with Tabbed Properties in Web Dynpro

Data Modeler

Java Editor

Message Editor

Metadata Comparison Tool for WD Projects

Metadata Comparison Tool

Web Dynpro Metamodel Object Search

Navigation Modeler

View Designer

View Designer Enhancements

Web Dynpro Explorer

Refactoring a Web Dynpro Object

Editing a Web Dynpro Object Inline

SAP Interactive Forms by Adobe

InteractiveForm API

Setting Up Authentication for Adobe Forms in Java Web Dynpro

Controller Class and Interface Reference

Common Controller Class Reference

Common Controller Interface Reference

Component Controller Class Reference

Component Controller Interface Reference

Custom Controller Class Reference

Custom Controller Interface Reference

View Controller Class Reference

View Controller Interface Reference

Window Controller Class Reference

Window Controller Interface Reference

Migration

Migrating to the Adaptive Web Service Model Type

Enabling Service Group Configuration for AWS Models

Migrating Adaptive RFC Model to Adaptive RFC 2 Model

Using Service Classes

Deployment Service

Configuration Service

Internationalization Service

URL Generation Service

User Management Service

Web Dynpro User Interface Snippets

Developer Studio Settings

Naming Conventions

General Rules

Recommendations and Restrictions

Concepts

Web Dynpro and the Model View Controller Design

Stateless Web Dynpro Applications

Applications

Components

Constituent Parts of a Component

Interfaces of Components

Faceless Component

Lifespan of a Component

Dynamic Component Usage

Models

Controllers

Controllers Having No Visual Interface

Controllers Having A Visual Interface

Arranging Multiple Views in a Window

Arranging Multiple Windows in a Component

View Navigation Plugs and Navigation Links

Window Navigation Plugs

Events and Actions

Tasks

Choosing the Client

Integrating WD Applications into SAP NetWeaver Portal

Developing Mobile Always Connected Applications

UI Elements for Mobile Always Connected Applications

Specifics of Nokia Series 80 and 60 Devices

Specifics of BlackBerry Wireless Handhelds

Specifics of Pocket PCs

Mobile Add-On Library

BarCodeReader

Using the BarCodeReader

FunctionKey

Using the FunctionKey

RFIDReader

Using the RFIDReader

Setting Up the Web Dynpro Development Component (DC)

Building Web Dynpro Development Components in Working Sets

Web Dynpro Development Component (DC)

Creating a Web Dynpro DC

Sharing Local Web Dynpro DCs in the NWDI

Repairing Web Dynpro DCs

Integrating Services

Importing Adaptive Web Service Models

Adaptive Web Service Model

Destination Service

Re-importing Adaptive Web Service Models

Viewing and Creating Service Groups in Web Dynpro Explorer

Importing JavaBean Models for DC Projects

Importing Enterprise JavaBean (EJB) Models

Enterprise JavaBean (EJB) Model

Creating an EJB Development Component (DC)

Developing the Business Logic

Creating an Enterprise Application DC

Preparing DC's for Use by Other Components

Setting Up the Web Dynpro Development Component (DC)

Creating Applications

Importing Adaptive Remote Function Call (RFC 2 ) Models

Importing Adaptive RFC Models (deprecated)

Defining Adaptive RFC Models

Invalidating Metadata Caches

Importing Models Using the Search Console

Editing Model Classes

Using the Test Mode to Populate Test Data in Web Dynpro

Structuring Web Dynpro Components

Creating Components

Defining Controllers

Adding Custom Controllers

Using Templates in Web Dynpro

Wrapping Services in Controllers

Implementing Components with Their Controllers and Interfaces

Implementing Component Controllers

Implementing View Controllers

Implementing Window Controllers

Controller Concept

Controller Class and Interface Reference

Controller Interface Concept

Defining Controller Relations

Adding Model References

Adding Windows

Defining Window Properties

Navigating to Web Applications

Suspend and Resume Plug

Specifying Dataflow

Binding Context to the Model

Defining Controller Relations

Creating Context Trees Manually

Data Binding

Bindable Data Types

Binding UI Element Properties to Dictionary Types

Binding UI Element Properties to the Context

Data Binding to predefined Dictionary Simple Types

Bringing Files To Context

Binding Tables

Binding Trees

Designing User Interfaces

Creating Views

Arranging Views in a Window

Arranging UI Elements in a View

Using UI Snippets to Create a Confirmation Dialog

Creating a Configurable Dropdown Using UI Snippets in Web Dynpro

Creating a Reset Button Using UI Snippets in Web Dynpro

Creating a Modal Window Using UI Snippets in Web Dynpro

Choosing the Layout

Adding UI Elements Manually

Creating UIs Using Drag and Drop of Context Elements

Creating UIs Using Drag and Drop of Model Class

Adding UI Elements Using View Templates

Creating Buttons, Events, and Plugs

Creating Tables With Direct Controller Access

Creating Forms Using Context Data

Adding UI Elements Programmatically

Subscribing to a Portal Event Using a Code Snippet

Unsubscribing a Portal Event Using a Code Snippet

Using Code Snippets to Fire a Portal Event

Using a Code Snippet to Execute a Model

Using Code Snippets to Fire a Plug

Using Code Snippets to Relate a Context Attribute

Assigning UI Element Properties

Common UI Element Properties

Methods of the UI Element APIs

Displaying and Formatting Core Data Types

Units of Measurement

Specifying the Image Source

Enabling User Interaction

Implementing Hot Keys

Enabling Access Keys

Creating Actions

Mapping Event Parameters to Action Parameters

Mapping the Generic Event Parameter nodeElement

Implementing Parameter Mapping

Implementing Drag and Drop

Modeling Navigation Between Views

Creating Plugs

Creating Navigation Links

Object-Based Navigation (OBN) Between WD Applications

Checking View Design

Running Web Dynpro Applications

Creating Applications

Configuring the Web Dynpro Runtime Environment

Configuring Applications

Setting Values of the Application Properties

Deploying Applications

Starting Applications

Adding WD-Specific Parameters to URL

Stopping Applications

Redirecting Clients to Other Servers

Ensuring Quality

Debugging Web Dynpro Applications

Debugging Web Dynpro Implementations

Debugging Contexts

Testing Web Dynpro Applications

Checking Monitoring Availability

Minimizing Byte Code

Web Dynpro Class File Minimizer

Extending Web Dynpro Components

Using Connections for Extensibility

Extending SAP Interactive Forms by Adobe

Providing Help

Offering Input Help

Providing Short Value Lists (SVS)

Providing Long Value Lists (EVS)

Providing Search Result Value Lists (OVS)

Modifying Helper UI

Generating Values Statically in Value Help

Modelling Value Help in Web Dynpro Applications

Showing Messages After User Interaction

User Messages

Defining User Messages

Displaying User Messages

Internationalizing Applications

Translating UI Texts

Sequence of Language Display

Content Administration and Measurements

Using SAP NetWeaver Administrator for Java Web Dynpro

Web Dynpro Application Modules

Web Dynpro Application Module List

Web Dynpro Console

Performance Data Within the Request Response Cycle

Measuring the Performance of the Web Dynpro Framework

Measuring Client Performance

Measuring Browser Client Performance

Displaying Performance Data for Requests

Measuring the Performance of the SAP Back End

Displaying Performance Data for Users

Web Dynpro Content Administrator

Starting the Web Dynpro Content Administrator

Functions for JCo Destinations

Creating JavaConnector (JCo) Destinations

Checking SLD Connections

Examining Deployed Web Dynpro Contents

Replacing Interface Texts at Runtime

Setting up a Web Dynpro Application for a Logon Ticket

Getting Started

New and Noteworthy Featues in Web Dynpro Tools For EhP2

Developing Your First Web Dynpro Application

Creating a Web Dynpro Development Component (DC)

Creating a Web Dynpro Application

Creating the Second View

Specifying the Navigation

Creating the Controller Context

Mapping View Contexts to the Component Controller Context

Creating Actions and Implementing Navigation

Designing a View Layout

Deploying and Running Your Application

Developing a Web Dynpro Application Using the Execution Modeler

Enabling a Simplified Modeling Environment

Opening Execution Modeler

Defining the UI Layout

Using Web Dynpro Model

Creating a Service Execution Link

Editing a Service Execution Link

Creating a Service Response Link

Creating a Service Chain Link

Editing a Service Chain Link

Creating a Navigation Link

Modeling a Popup Window

Deleting a Link

Modeling Composite Views with Visual Composer

Getting Started

Introducing Visual Composer

Visual Composer Overview

Visual Composer Architecture

Architecture of Visual Composer in a Web Browser

Architecture of Visual Composer in the Developer Studio

Prerequisites

Accessing Visual Composer in a Web Browser

Introducing the Storyboard Desktop

Typical Workflow

Creating a Model

Locating the Data Services

Designing the Component Logic and Flow

Designing the User Interface

Deploying the Model

Modeling Your First Application with Visual Composer

Tutorial 1: Modeling a Simple Application

Creating the Base Model for Retrieving Product Information

Modeling the Currency Converter Application

Adding a Currency Converter Popup

Tutorial 2: Modeling an Advanced Application

Creating the Base Model for Retrieving Buyer Information

Adding a Second Data Service and Preparing for Reuse

Reusing a Model and Enabling Personalization

Tutorial 3: Enhancing the Advanced Application

Creating an Entry List

Checking That a Field Value is Entered

Displaying Information in a Popup Window

Adding a Product Image

Creating a Model and Development Component

Opening a Model

Saving a Model

Saving a Copy of a Model or Development Component

Closing a Model

Importing a Model

Exporting a Model

Creating a New Software Component

Managing Models

Working with Source Control

Adding a Development Component or a Model to Source Control

Checking In a Model

Checking Out a Model

Reverting to the Last Checked-In Version of a Model

Synchronizing a Model

Designing the Composite View

Discovering Data Services

Discovering Services in the Services Registry

Working with Stored Procedures

Reusing Components

Modifying Referenced Components

Composing the Composite View

Introducing the Compose Task Panel

Connecting Model Elements

Configuring the Composite View

Working with Dynamic Expressions

Dynamic Expression Editor Dialog Box

Messages in the Dynamic Expression Editor Dialog Box

Defining Dynamic Expressions

Tables of Functions

Text Functions

Text Type Classifications

Numeric Functions

Number Formatting Mask

Conditional Functions

Scientific Functions

Dynamic Expression Operators

Dynamic Expression Keywords

Defining Data

Mapping Data

Laying Out the UI

Defining Layout Options

Adding Controls

Controls Overview

Adding Controls in a Melting Group

Configuring Controls

Configuring Actions

Creating Entry Lists

Working with Global Entry Lists

Defining Control Styles

Defining Images

Creating Toolbars

Defining Table Styles

Performing Advanced Modeling Tasks

Finding and Modifying References

Storing Data in a Data Store

Replacing Components

Creating a Multi-Selection Table

Defining Popups

Enabling Customization of Table Views at Runtime

Enabling CCM Personalization of Table Views at Runtime

Creating Service Components

Creating a Service Using the Service Component Wizard

Using Eventing to Transfer Data between Components

Transferring Data Using a Data Share

Defining Validation Rules

Managing System Aliases

Preparing Models for Translation

Modeling Composite Views for Use in Business Process Management

Modeling Composite Views for Use in Guided Procedures

Creating an Error Report

Migrating Models from Visual Composer for SAP NetWeaver 7.0

Table of Conversions

Compiling and Deploying Models

Troubleshooting

Viewing Log Files

Working with Visual Composer in SAP NetWeaver Developer Studio

Launching Visual Composer

Configuring Visual Composer in Developer Studio

Creating a Local Development Component

Understanding the Visual Composer DC Structure

Creating RFC Destinations

Creating Web Service Destinations

Creating a JDBC Connection Profile

Configuring Systems for Deployment

Enabling the Service Group in Visual Composer

Working with Source Control

Importing a Development Configuration

Creating a Development Component in Source Control

Synchronizing a Development Component in the Model Browser

Adding a Local Development Component to Source Control

Checking In a Model

Checking Out a Model

Reverting to the Last Checked In Version of a Model

Resolving Conflicts in the Component Definition File

Working with the Model Browser

Integrating Components Using Search Console

Adapting ESOA Services for Use in Visual Composer

Using Web Services in Visual Composer

Using Web Dynpro Components in Visual Composer

Using the CMI EJB Service in Visual Composer

Debugging Models in Developer Studio

Getting Started with the Debugger

Working with Breakpoints

Adding or Removing a Breakpoint on the Design Board

Adding or Removing a Breakpoint on the Layout Board

Disabling and Enabling Breakpoints

Unreachable Breakpoints

Stepping Through the Application

Defining Expressions for Debugging

Monitoring the Debug Process

Monitoring Application Execution in Debug View

Viewing Data Flow in Variables View

Viewing Step Information in Step Details View

Modeling Composite Views Using BI Data Services

Designing Composite Views Using BI Data Services

Designing Composite Views Using BI Integrated Planning

Structure of a BI Data Service

Visual Composer Reference Guide

Main Workspace Elements

Configuration Dialog Boxes

Manage Services Dialog Box

Options Pane

Options Pane - Model Group

Options Pane - Design Group

Options Pane - Performance Group

Options Pane - Compiler Group

Options Pane - Embedded Support Group

View Runtime Configuration Dialog Box

Model Menu Dialog Boxes

Create New Model Dialog Box

Export Model Dialog Box

Import Dialog Box

Save As Local Copy Dialog Box

Task Panels

Get Started Task Panel

Manage Models Task Panel

Add Model to Source Control Dialog Box

Add to Source Control Dialog Box

Activity Description Dialog Box

Create New Development Component Dialog Box

Create New Software Component Dialog Box

Browse Task Panel

Compose Model Task Panel

Compose Model Task Panel (Design Board)

Compose Model Task Panel (Layout Board)

Configure <Element> Task Panel

Configure Button Task Panel

Configure Calendar Task Panel

Configure Chart View Task Panel

Configure Checkbox Task Panel

Configure Combo Box Task Panel

Configure Composite View Task Panel

Configure <Connecting Line> Task Panel

Configure <Connector> Task Panel

Configure Data Source Task Panel

Configure Date Picker Task Panel

Configure DateTime Picker Task Panel

Configure Dropdown List Task Panel

Configure Form View Task Panel

Configure Gauge Task Panel

Configure Horizontal Separator Task Panel

Configure Horizontal Slider Task Panel

Configure HTML View Task Panel

Configure Hyperlink Task Panel

Configure Image Task Panel

Configure Input Field Task Panel

Configure Layer Task Panel

Configure Nested View Task Panel

Configure Note Task Panel

Configure <Operator> Task Panel

Configure Panel Task Panel

Configure Plain Text Task Panel

Configure Popup Task Panel

Configure Progress Bar Task Panel

Configure Radio Group Task Panel

Configure Service Component Task Panel

Configure Spinner Task Panel

Configure Table View Task Panel

Configure Tabstrip Task Panel

Configure Text Editor Task Panel

Configure Toggle Button Task Panel

Configure Vertical Separator Task Panel

Configure Vertical Slider Task Panel

Configure View Switch Task Panel

Configure Window Task Panel

Configure Wizard Task Panel

Search Task Panel

Advanced Search Dialog Box

Search Task Panel for BI Data Services

Deploy Task Panel

Wizards

Entry List Wizard

Entry List Wizard: Select Entry List Type

Entry List Wizard: Define List Items

Entry List Wizard: Select Data Service

Entry List Wizard: Configure Input

Entry List Wizard: Configure Output

Edit Entry List Dialog Box

Model Migration Wizard

Model Migration Wizard: Source Model Selection

Model Migration Wizard: System Alias Selection

Model Migration Wizard: Migration Report

Service Component Wizard

Service Component Wizard: Define Service Name

Service Component Wizard: Define Data

Service Component Wizard: Define Input

Service Component Wizard: Define Conditions

Services Registry Wizard

Services Registry Wizard: Find Service

Services Registry Wizard: Select Definition

Services Registry Wizard: Select Endpoint

View Dialog Boxes

Customize Column Widths Dialog Box

Default URL Dialog Box

Define Cell Styles Dialog Box

Define Row Styles Dialog Box

Edit Data Series Dialog Box

Edit Title Dialog Box

Select Event Dialog Box

Control Dialog Boxes

Browse Images Dialog Box

Define Action Dialog Box

Define Styles Dialog Box

Define Validation Rules Dialog Box

Operator Dialog Boxes

Define Aggregate Dialog Box

Define Distinct Dialog Box

Define Filter Dialog Box

Define Sort Dialog Box

Define Switch Dialog Box

Define Union Dialog Box

Data Dialog Boxes

Define Data Dialog Box

Initialize Data Dialog Box

Map Data Dialog Box

Redefine Ports/Reload Component/Reload Data Service/Replace Comp

Test Data Service Dialog Box

Expression Dialog Boxes

Dynamic Expression Editor Dialog Box

Find All Expressions Dialog Box

Find Element References Dialog Box

Find Field References Dialog Box

BI Services Dialog Boxes

BI Query Wizard

BI Master Data Wizard

Planning Function Dialog Box

Planning Sequence Dialog Box

Planning Command Dialog Box

Developing Voice-Enabled Applications

Getting Started

Voice Development FAQ

Understanding the Voice Kit Storyboard Desktop

Developing a Simple Voice Application

Concepts

Voice Application Design

Understanding the Design with an Example

Voice Application Internationalization

Voice Application Architecture

Voice Componentization

Voice Entities

Context Entities

Tasks

Creating Voice Applications

Creating Voice Models

Adding Voice Entities to a Voice Model

Adding Non-Voice Entities to a Voice Model

Enabling Voice and Non-Voice Entities

Enabling Voice Applications

Specifying General Fields

Specifying Advanced Settings

Specifying Deployment Fields

Specifying Fetchaudio Fields

Specifying Resource Target Defaults Fields

Internationalizing Voice Applications

Defining Multiple Languages at Application Level

Defining Multiple Languages at Entity Level

Compiling Voice Applications

Deploying Voice Applications

Testing Voice Applications

Testing Voice Applications using STAG

Tracing Voice Applications

Reference

Working With Variables

Working With Formal Parameters

Description of the Entity Fields

URL Parameters of a Voice Application

Composing Services with Service Composer

Concepts

Tasks

Creating Service Interfaces or Services

Simplifying Services

Composing Services

Modeling the Service Flow

Importing WSDL and XSD Files

Importing RFC Modules

Mapping a Service Operation's Input and Output

Generating the Composed Service

Reimporting Modified WSDL and XSD Files

Creating Mock Services

Securing Composed Services

Applying an Authentication Policy in Composed Services

Enabling Endpoints for Security

Composing Services with CAF

Getting Started

Opening the Composite Application Perspective

Developing Your First Composite Application

Creating a New Application Project

Modeling Business Object Nodes

Defining Business Objects Operations

Creating an Application Service

Creating Application Service Operations

Implementing Application Service Operations

Generating Code and Building Services

Testing Your First Application

Developing Your First Permission Checks Implementation

Implementing Permission Checks for Business Objects

Testing Permission Checks for Business Objects

Configuring Authorizations for Business Objects

Consuming ES Workplace Web Services in CAF

Importing the Web Service

Creating and Modifying the Application Service

Configuring Web Service Clients to Connect to a Provider System

Testing the Application Service

Composite Application Development Components

Tasks

Creating Composite Application Development Components

Creating Service Interfaces or Services

Managing Data Types

Securing Your Composite Application

Protecting Access to Application Service Operations

Protecting Access to Business Object Operations

Managing the Business Rules List

Managing the Access Control List

Managing the Conditions List

Modeling Business Objects

Creating Business Objects

Enabling Change Log for CAF Business Object Node

Modeling Business Object Attributes

Modeling Service Operations

Defining Business Object Persistency

Defining Business Object Associations

Exposing Application Services or Business Objects as Web Service

Locking Business Objects

Implementation Example for Locking Business Objects

Modeling Application Services

Creating Application Services

Modeling Service Operations

Defining Application Service Dependencies

Filtering Business Object Instances in Application Service

Exposing Application Services or Business Objects as Web Service

Using External Services

Importing RFC Modules

Importing Web Services

Configuring Destinations for Old Types of CAF Applications

Mapping Service Operations

Rules for Service Mapping

Reimporting External Services

Deleting External Services

Implementing Web Services in CAF

Publishing Web Services in Service Registry with CAF

Translating Language Dependent Attributes

Modeling a Composite Application Using CAF Diagram

Developing with CAF in Team-Oriented Environment

Resolving Conflicts in CAF

Testing Services with the Service Browser

Transporting CAF Content Between Different Applications

Integrating KM Documents in CAF

Configuring CAF to Use KM Repository

Configuring the AS Java to Accept Logon Tickets

Configuring the CAF KM Web Services on the CAF Side

Configuring Repositories on the CAF System

Securing the Server

Cleaning Temporary Documents in KM

Creating and Reading a KM Document from CAF Services

Locking and Unlocking a KM Document

Versioning a KM Document

CAF and SAP NetWeaver BW Integration

Configuring CAF for SAP NetWeaver BW Integration

Data Extraction in CAF and SAP NetWeaver BW Integration

Extractor Method Implementation Example

CAF DataSources Used in SAP NetWeaver BW

DataSource Name Restrictions

DataSources to Access Business Object Node Attributes

DataSources for Language-Dependent Attributes

DataSources for Business Object Associations

DataSources for BI Extractor Operations of Application Services

Enabling CAF Application Services for Extensibility

Reference

Composite Application Perspective Tab Pages

General Tab Page

Associations Tab Page

Implementation Tab Page

Predefined Services and Data Types

Supported Web Service Structures and Facets

XSD Data Types Mapping

Integrating CAF Services in Composite Views and Processes

Working with Data Mappings

Data Mapping Rules

Defining Data Mappings

Performing Complex Data Transformation with Functions

Creating Expressions

Editing Functions

Creating an External Function, Exposing It as an EJB, and Using

Defining Mappings Using the Automapping Option

Applying Quick Fixes in Data Mappings and Expressions

Reference

Data Type Compatibility

Built-In Functions

Generic Functions

Example of an EJB Function, Exposed as a Mapping Function

Quick and Easy Mapping

Developing Java EE 5 Applications

Getting Started

Configuring the Application Server in the Developer Studio

Developing Your First Java EE 5 Application

Developing the EJB 3.0 Module

Developing the Web Module

Deploying and Running the Enterprise Application

Concepts

Java EE 5 Development Tools

Java EE Perspective

JPA Perspective

Deploy Perspective

Java Enterprise Edition 5 Overview

Overview of the Java Persistence API

Entities

Entity Manager

Entity Manager Operations

Relationships

Relationships Mapping Principles

Cascading Entity Manager Operations

Native Databases with Foreign Key Constraints

Queries

JPQL Queries on a Native SQL Execution Layer

Generated Primary Keys

Inheritance

persistence.xml

Running JPA Applications on the System Data Source

Versioning and Dirty Reads

Caches in the JPA Implementation

Web Services

JavaServer Faces

Tasks

Developing Persistence

Overview of the Java Persistence Infrastructure

Using JPA in the Persistence Layer

Creating Connections to the Java Dictionary

Creating Database Connections

Creating JPA Projects in the Developer Studio

Creating Entities and Generating Database Tables

Creating Database Tables and Generating Entities

Working with the Entity Manager

Obtaining an Entity Manager Instance

Managing Entity Instances

Creating and Executing Queries

Configuring the Persistence Unit in the persistence.xml

Creating Data Models with the JPA Diagram Editor

Using Open SQL/JDBC in the Persistence Layer

Getting a Connection to the Database

Inserting Data Into a Table

Using Queries

Semantics of the Data Types DATE, TIME, and TIMESTAMP

Transactions in Open SQL/JDBC

Native SQL Access

Error Handling

Using Open SQL for Java Features

Table Buffer

Buffer Granularity

Statements Using the Buffer

Statements Bypassing the Buffer

Modifications and Actions on the Remote Buffers

Reading and Writing LOBs En Bloc

Using Locators

Using Streams

Numbers

DATE, TIME and TIMESTAMP Values

Value Checker API

Handling Transactions and Resources in Applications

Introduction to Transactions in AS Java

JTA Implementation

JTS Implementation

JTA and Local Transactions

Distributed Transactions

Using Local Transactions

Two-Phase Commit

Transaction Synchronization Registry

Resource Handling Mechanism

Connection Handling in JTA and Local Transactions

Database Connection Management

JTA Transaction Recovery

Configuring the Transaction Service

Transaction Service Properties

Using Container-Managed JTA Transactions

Using Component-Managed JTA Transactions

Sharing Connections

Monitoring Distributed Transactions

Locks

Enqueue Locks

Working with Enqueue Locks

Locking Protocols

Working with the TableLocking API

Setting Locks with the TableLocking API

Releasing Locks with the TableLocking API

Working with the LogicalLocking API

Getting a LogicalLocking Instance

Setting Locks with the LogicalLocking API

Releasing Locks with the LogicalLocking API

Reconnecting to the DB in the Event of a DB Crash

Developing Business Logic with EJB 3.0

EJB Overview

Creating EJB 3.0 Projects in the Developer Studio

Creating Session Beans in the Developer Studio

Setting a Session Timeout

Creating Message-Driven Beans in the Developer Studio

Setting the MDB Properties in the ejb-j2ee-engine.xml

Administering Message-Driven Beans (MDBs)

Using Dependency Injection

Editing EJB Environment

Specifying Transaction Attributes

Specifying Security

Using Interceptors and Life Cycle Callbacks

Using Java Persistence API (JPA)

Using Session Bean CRUD Facade Template

Using CRUD Application Template

Using Enterprise JavaBeans as Web Service Endpoints

Editing the ejb-j2ee-engine.xml

Using Timers

Testing an Application's Business Logic Using the EJB Explorer

Binding the Life Cycle of Application and Business Components

Accessing Enterprise JavaBeans from Remote Clients

Connecting to Enterprise Beans on SAP NetWeaver 2004 AS Java and

Developing User Interfaces

Creating Dynamic Web Projects

Using Annotations in Web Applications

Annotations in Web Applications

Injecting EJB Resources into Web Applications

Injecting Resources into Web Applications

Accessing Persistence in Web Applications

Configuring Methods Using Annotations in Web Applications

Configuring Security Roles Using Annotations in Web Applications

Developing JavaServer Faces (JSF) Web Applications

Creating the JSF UI Components

Creating JSF JSP Files

Standard JSF Tags

Dynamic Data Tables

Command Buttons

Validating User Input

Managed Beans

faces-config.xml

Using the SAP Component Library for JSF

Developing Servlets

Creating Servlets in the Developer Studio

Initializing Servlets

Servicing Client Requests

Retrieving Client Input

Retrieving Multipart Request Messages

Request Attributes When Using Application Zones

Obtaining the Remote Host Address

Composing HTTP Responses

HTTP Response over Persistent Connections

IOException in Cases When Client Closes Connection

Threadsafe Servlets

Handling Cookies in Servlets

Setting Cookies in HTTP Servlets

Retrieving Cookies from the HTTP Request

AS Java Cookies

Servlet-defined Cookies

HTTP Sessions

Lifetime of a Session

Session Tracking with Servlets

Accessing and Manipulating the Session Object

Terminating a Session

URL Rewriting as an Alternative to Cookies

HTTP Sessions and Failover of Web Applications

Dispatching Requests to Web Application Resources

Including Requests

Forwarding Requests

Destroying Servlet Instances

Developing Event Listeners

Developing Filters

Developing JSP Pages

Creating JSP Files in the Developer Studio

JSP Life Cycle

Syntax Elements Outline

Using the page Directive

Implicit Objects

Standard Actions

Including and Forwarding Requests in a JSP

JSTL

Developing Custom Tags

Developing Classic Tag Handlers

Developing Simple Tag Handlers

Developing TLD Files

Describing Tag Handlers in TLD Files

Developing Tag Files

Describing Tag Files in TLD Files

Unified Expression Language

EL Expressions in Tag Attribute Values

Deferred Expressions Evaluation

Using EL Implicit Objects

Developing EL Functions

Developing Portlets

Packaging and Deployment Descriptor

Using CC/PP with Portlets

Customizing Default Error Pages

Defining Custom HTTP Response Status Codes

Editing the web-j2ee-engine.xml

Configuring Resource References Using the web-j2ee-engine.xml

Example: Describing Data Sources in the web-j2ee-engine.xml

Example: Describing JMS Connection Factories in the web-j2ee-eng

Creating and Configuring Web Services and Web Service Clients

Providing Web Services

Providing Web Services Inside Out

Creating an Inside-Out Web Service from an Enterprise Java Bean

Creating an Inside-Out Web Service from a Java Class

Service Endpoint Interface

Providing Web Services Outside In

Importing WSDL Documents in the SAP NetWeaver Developer Studio

Creating Outside-In Web Services

Collision Resolution and Global Customizations

Using Interactive Conflict Resolution

Using Automatic Conflict Resolution

Using JAX-WS Customization Files

Using No Customizations

Global Customizations

Browsing Enterprise Services from the SAP NetWeaver Developer St

Browsing Services in Search Console

Configuring Connections to Solution Composer Systems

Searching for Enterprise Services in Solution Composer

Searching for RFC Function Modules

Searching for Web Services in the Local Workspace

Importing Enterprise Services in the Workspace

Importing RFC Function Modules in the Workspace

Browsing Services in Search Favorites

Providing TU&C/C Web Services

Processing Large Data by Web Services

Configuring Web Services at Design Time

Setting an Authentication Level

Setting the Transport Guarantee Level

Configuring a One Way Message Exchange Pattern

Configuring Web Services Reliable Messaging

Configuring Stateful Communication

Connecting the SAP NetWeaver Developer Studio to the Services Re

Configuring Resource Management Settings

Adding Classifications to Web Services

Viewing Web Service Artifacts

Editing the Properties of Web Service Artifacts

Restrictions to Web Service Implementation Beans

Consuming Web Services

Creating Web Service Proxies

Creating Service Groups

Creating Shared Service Groups

Creating Private Service Groups

Creating Predefined Service Groups

Creating Classified Service Groups

Editing Service Groups and Service References

Creating Web Service Client Applications

Consuming TU&C/C Web Services

Consuming Idempotent Web Services

Extended Proxy Capabilities

Importing Applications Created with Previous Releases of SAP Net

Configuring Web Services and Web Service Clients in the SAP NetW

Concepts

Connection to Provider Systems

Configuration of Destinations to Provider Systems

Configuration of Individual Web Services and Web Service Clients

Configuration of Groups of Web Services

Configuration of Groups of Web Service Clients

Security Considerations for Service Groups

Service Metering

Service Metering for Non-SAP Service Consumers

Preparing Communication Profiles

Configuring Web Service Connectivity to Communication Profiles

Configuring Remote Function Call Connectivity to Communication P

Creating Connections to Provider Systems

Creating a Connection

Configuring Web Service Connectivity

Configuring Remote Function Call Connectivity

Editing a Connection

Activating and Deactivating a Connection

Exporting and Importing a Connection

Creating User Accounts

Configuring Web Service Connectivity to User Accounts

Configuring Remote Function Call Connectivity to User Accounts

Assigning User Accounts

Configuring Web Services

Configuring Groups of Web Services

Configuring Web Services Exposed by Applications

Grouping and Configuring Web Services in Business Scenarios

Configuring Individual Web Services

Managing WSDL Documents

Configuring WSDL Security

Accessing Information Provided via WSIL

Configuring Web Service Clients

Configuring Groups of Web Service Clients

Configuring Consumer Applications

Consumer Application Details

Configuring the Consumer Side of Business Scenarios

Creating Business Scenarios

Editing Business Scenarios

Configuring Service Groups Manually

Adding and Removing Service Groups

Adding and Removing Services

Configuring Individual Web Service Clients

Configuring Web Service Connectivity Options to Logical Ports

Creating Web Service Physical Destinations

Configuring SAP NetWeaver Administrator

Authorizations

Configuring Proxy Settings

Configuring Reverse Proxy Settings

Configuring Host Mapping, Path Prefix, and Path Mapping

Mappings for Host and Port

Mappings for URL Published in Services Registry

Path Mappings

Configuring Web Services Navigator White List

Modifying SOA Configuration Background Process Settings

Testing Web Services in the Web Services Navigator

Testing a Web Service

Finding Web Services

Testing a Web Service Operation

Examining Test Results

Changing Invocation Parameters

Importing Test Data from a URL

Using Test Scenarios

Creating Test Scenarios

Executing Test Scenarios

Editing Test Scenarios

Publishing to the Services Registry

Publishing Web Services from the SAP NetWeaver Administrator

Publishing Service Groups from the SAP NetWeaver Administrator

Monitoring Web Services

Configuring Connectivity Logging

Viewing Connectivity Log

Monitoring Messages

Advanced Search of Web Service Messages

Monitoring Sequences

About Sequences

Choosing Selection Criteria

Checking the Sequence Overview

Analysis of Sequence Details

Rejecting and Restarting Sequences

Supported Specifications

Tutorials

Developing a HelloWorld Web Service

Creating the HelloWorld Web Service

Creating an Enterprise Java Bean Project for the HelloWorld Web

Creating the Enterprise Java Bean

Exposing the Enterprise Java Bean as a Web Service

Deploying the HelloWorld Web Service

Testing the HelloWorld Web Service

Creating the HelloWorld Web Service Client

Creating a Dynamic Web Project for the Web Service Client

Importing the WSDL Document

Generating the Web Service Proxy

Creating the Web Service Client Application

Deploying the HelloWorld Web Service Client

Exposing and Configuring the Converter Application as a Web Serv

Exposing the Converter Application as a Web Service

Importing the Converter Application in the SAP NetWeaver Develop

Exposing the Implementation EJB as a Web Service

Setting an Authentication Level to the Web Service

Deploying the Converter Web Service

Configuring the Web Service in the SAP NetWeaver Administrator

Testing the Converter Web Service

Creating the Converter Web Service Client

Creating a Dynamic Web Module for the Converter Consumer Applica

Importing the Converter WSDL Document

Generating the Converter Web Service Proxy

Generating the Converter Service Group

Creating the Converter Web Service Client Application

Deploying the Converter Web Service Client

Configuring the Web Service Client in the SAP NetWeaver Administ

Setting Severity to Web Services and Web Service Clients

Starting the Converter Web Service Client Application

Viewing Converter Web Service and Web Service Client Logs and Tr

Using Java Message Service

JMS Overview

JMS Clustering and Failover

JMS Connector Concept and Related Tasks

Creating and Configuring JMS Virtual Providers

Creating and Configuring JMS Resources and Resource References

Property Reference

Accessing JMS Resources

Using JMS Resources from Two and More Applications

Creating Message Producers and Consumers

Using Queue Browsers

Using Durable Subscriptions

Using Message Selectors

Message Selector Syntax

Consuming Messages from Message-Driven Beans

Processing Messages

Handling Dead Messages

Defining Security in JMS

Using Transactions

Configuring Transaction-Related JMS Connection Factory Propertie

Using JMS XA Transactions

Using a Third-Party JMS Provider

Using JMS Store-and-Forward

Monitoring JMS Provider Using Telnet

Handling Exceptions

Example

Developing JCA Resource Adapters

Creating Connector Projects in the Developer Studio

Implementing 1.5 Resource Adapter

What's New in JCA 1.5

The Resource Adapter JavaBean

Outbound Communication

Inbound Communication

Message Endpoint Activation

Message Inflow Scenario

Transaction Inflow Support Implementation

Implementing the Work Management Contract

Implementing 1.0 Resource Adapter

Implementing Connection Management

Implementing Transaction Support

Implementing Interaction Functions

Assembling and Configuring the Resource Adapter

Resource Adapter Archive (RAR)

ManagedConnectionFactory Configuration

Resource Adapter Transaction Support

Connection Pooling

Resource Adapter Classloading

Using Resource Adapter to Obtain a Connection

Driving an Interaction with the EIS

Developing Application Clients

Working with Libraries

Using Shared Libraries

Using Bundled Libraries

Migrating Old Library Projects

Using Heavy Class Loaders

Heavy Class Loaders

Assembling Components into Enterprise Applications

Creating Enterprise Application Projects

Adding Modules to the Enterprise Application

Adding the application.xml to Enterprise Application Projects

Editing the application-j2ee-engine.xml

Referencing Non-Existent Bundled Libraries

Editing Runtime References in the application-j2ee-engine.xml

Deploying Applications

Security Actions Necessary to Perform Deploy Operations

Deploying and Undeploying with SAP NetWeaver Developer Studio

Building, Publishing and Removing Published Java EE Applications

Deploying Archives

Working with Deploy Templates

Managing Deployed Archives

Undeploying Archives

Managing Substitution Variables

Viewing Deployment Related Logs

Filtering and Sorting Archives

Deploying Applications with Third-Party Deployment Tools

Using Ant Scripts to Work with SDAs

Using Shell Scripts to Work with SDAs

Managing the Application Environment

Creating Your Own Application Tables in the Database

demotables.sql

Working with DataSources

Deploying DataSources

Deploying DataSource Aliases

Deploying JDBC Drivers

Creating J2EE 1.4 Applications in SAP NetWeaver Developer Studio

Creating J2EE 1.4-Compliant Web Components

Creating EJB 2.1 Components

Assembling J2EE 1.4-Compliant Enterprise Applications

Debugging Java EE Applications

Configuring AS Java for Debugging

Creating Debug Configurations in the Developer Studio

Stopping Remote Debugging

Creating Platform-independent Java EE Applications

Migrating Existing Java EE Applications to AS Java

Using AS Java APIs

Using JavaMail

Configuring the JavaMail Client Service

Obtaining a Session Object

Creating E-Mail Messages

Sending E-Mail Messages

Receiving E-Mail Messages

Creating Secure Connections Using JavaMail

HTTP Client

HTTP Client Properties

Simple Get Request to a Specified Host and Port

Get Request Using Proxy

Posting File Using Chunked Encoding

Get Request Using Basic Authentication

Managing System and Application Configurations

Configuration Manager

Monitoring Configurations

Java Configuration Browser

Adding Configuration Capabilities to an Application

Connecting As an AS Java Application

Deploying Properties Within an Application

Accessing Application Properties

Registering a Property Change Listener

Modifying Application Properties

Accessing the System Profile

Naming and Directory Services (JNDI)

JNDI Registry Service

Creating an Initial Context

Binding Objects

Looking up Objects

Browsing the Naming Tree

JNDI Browser

NAMING Shell Commands

Using JNDI Registry Service to Locate Resources

RMI-P4 Overview

Developing Distributed Applications Based on RMI-P4

Defining a Remote Interface

Implementing the Remote Interface

Binding the Implementation to the Naming System

Implementing a Client

Accessing Enterprise JavaBeans from Remote Clients

RMI-P4 Reference

Using P4 Protocol Over a Secure Connection

Network Configuration for RMI-P4

Advanced P4 Protocol Connection Configuration

RMI-P4 Specific InitialContext Properties

Reference

Deployment Descriptors

appclient-j2ee-engine.xsd

application-j2ee-engine.xsd

application-service.dtd

connector-j2ee-engine.xsd

ejb-j2ee-engine.xsd

ejb-j2ee-engine_3_0.xsd

data-source-aliases.dtd

Tutorials

Project Management and Employee Services Application

Running the Application

Setting Up Application Users

Application Users and User Groups

Running the Predeployed Application

Deploying and Running the Application from NWDS

Application Data Model

Developing a Message-Driven Bean Application

Creating an EJB 3.0 Project and an EAR Project

Developing the Message-Driven Bean

Configuring the JMS Resources

Deploying the EAR

Sender JMS Client Example

Running the Example

Developing an Application Client

Creating and Implementing an EJB 3.0 Project

Creating and Implementing the Application Client

Deploying the Application

Running the Application Client

Creating an Adaptive RFC2 Sample Application without using Web D

Java Persistence Reference

Overview of the JDBC API

JDBC Java Packages

java.sql

javax.sql

JDBC Java Classes and Interfaces

java.sql.Blob

java.sql.Clob

java.sql.Connection

java.sql.DatabaseMetaData

java.sql.Driver

java.sql.PreparedStatement

java.sql.ResultSet

java.sql.ResultSetMetaData

java.sql.Statement

Open SQL Reference

Open SQL Database Dependencies

Delimited Identifiers

SELECT FOR UPDATE Statement

Value expressions

Column References

Set Functions

Arithmetic Expressions

Dynamic Parameter Specification

Search Condition

Comparison predicate

Scalar Subqueries

Quantified comparison predicate

Data Type Conversion Tables

Mapping JDBC Types to Java Types

Type Conversions Supported by ResultSet Getter Methods

Type Conversions Supported by PreparedStatement Setter Methods

Open SQL Type Propagation

Using Central Development Services

Using the Portal as a Frontend

Consider Accessibility

Technical Requirements for Accessibility

Accessibility in Web Dynpro for Java Applications

Important Disclaimers on Legal Aspects