Java Development Manual

Getting Involved

Concepts of the Developer Studio

Eclipse as an Integration Platform

SAP Toolsets and Perspectives

The Web Dynpro Toolset

Working with J2EE Tools

The Web Services IDE

Persistence Tools

The SAP Enterprise Connector

Testing Java Applications

SAP Perspectives

Development Configurations Perspective

Web Dynpro Perspective

J2EE Development Perspective

Web Service Perspective

Dictionary Perspective

The DTR Client Perspective

SAP Development Infrastructure for Java

Working with the Developer Studio

Starting the Developer Studio

Starting the Developer Studio Using a Batch File

Setting Workspace Using the – data Parameter

Changing the Default Workspace

Setting the Java VM Using the - vm Parameter

Using Other Start Parameters

Working with J2EE Tools

Basic Functions

Creating EJB Projects

Creating Stateful Session Beans

Creating Stateless Session Beans

Creating Entity Beans

Creating Message-Driven Beans

Editing Enterprise Beans

Creating and Editing the Enterprise Beans' Methods

Creating the Bean's Persistent Fields

Creating Beans' Relationships

Propagating Methods to the Remote and Local Interfaces

Building EJB JARs

Creating Web Projects

Creating JSP Files

Creating Servlets

Creating Filters

Creating Listeners

JSP Editor

HTML Editor

Building WARs

Creating Enterprise Projects

Adding Modules to Enterprise Projects

Building EARs

Specifying Additional Libraries to be Packed into EAR Files

Deploying EARs

Creating Data Source Aliases

Creating Packages

Configuring the J2EE Tools

Editors for Deployment Descriptors

EAR Configuration

Editing application.xml

Specifying Application Display Information

Specifying Alternative URIs

Specifying the Context Root

Adding and Removing Security Roles

Editing application-j2ee-engine.xml

Editing Application References

Enabling and Disabling HTTP Failover

Specifying the Additional Classpath

Specifying the Application Startup Mode

Adding and Removing Additional Modules

WAR Configuration

Editing web.xml

Editing web-j2ee-engine.xml

JAR Configuration

Editing ejb-jar.xml

Editing ejb-j2ee-engine.xml

Editing persistent.xml

Working with J2EE Engine Libraries

Defining Libraries

Creating a Library Project

Adding JARs and References

Creating a Library Archive

Deploying a Library Archive

Defining Library DCs

Creating a Library DC

Declaring the Use of Other DCs

Executing the Component Build

Referencing Libraries in Applications

Declaring Explicit References to Libraries

Declaring Implicit References to Libraries

Importing J2EE Sources

Importing J2EE Projects in the SAP NetWeaver Developer Studio

SAP Web AS 6.20 and the SAP NetWeaver Developer Studio

Migrating from Web AS 6.20

Assembling Enterprise Beans from Existing Classes

Propagating Metadata from ejb-jar.xml to Sources

Diagram View

Creating Packages in the Diagram View

Editing EJB Projects in the Diagram View

Creating Enterprise Beans in the Diagram View

Creating EJB Relationships in the Diagram View

Editing ejb-jar.xml in the Diagram View

Editing Web Projects in the Diagram View

Creating Folders in the Diagram View

Creating JSP and HTML Pages in the Diagram View

Importing Resources in the Diagram View

Editing web.xml in the Diagram View

Editing Enterprise Projects in the Diagram View

Web Dynpro Tools

Controller/Context Editor

Context Structure

Model Binding

Providing Data Using Value Nodes and Value Attributes

Data Modeler

Creating a Data Link

View Templates

Using the Form Template

Using the Table Template

Using the ActionButton Template

Using the Service Controller

Using the Relate Context Attribute Template

Message Editor

Creating a User Message

Navigation Modeler

Creating a View

Creating a View Set

Embedding a View in a View Set

Creating a Plug

Creating a Link

View Designer

Working with User Interface Elements

The User Interface Element Container

Chart Designer

Calling the Chart Designer

Web Dynpro Explorer

Creating a Project

Creating a Web Dynpro Development Component Project

Web Dynpro Class File Minimizer

Importing a Project

Deleting a Project

Navigator

Web Dynpro Model Tools

Importing an Adaptive RFC Model

Adaptive RFC

Reusing BAPI Data

Multiple Back End Support for the Adaptive RFC Model

Importing a Web Service Model

Importing a JavaBean Model

Using External Data Imported from an XMI Model

Conditions for an XMI Model Import

Referencing a Model

Java Dictionary

Modifying Dictionary Preferences

Development Process

Creating Data Types

Initial Values

Creating Structures

Reference Fields

Tables

Creating Tables

Buffering Type

Creating Indexes

Deploying Tables

Editing Table Definitions

Web Service Toolset

Web Service Perspective

Creating a Web Service

The Development Process

Creating a Web Service for an Enterprise JavaBean

Web Service Creation Wizard

Creating a Virtual Interface

Creating a Web Service Definition

Creating a Web Service and a Web Service Configuration

Creating a Web Service for a Java Class

Creating a Web Service from a Portal Service

Web Service Navigator

Advanced Techniques

Creating a Web Service with Attachments

Maintaining SOAP Extensions

Consuming a Web Service

Creating a Deployable Proxy

Creating a Client Bean

Creating a Client Servlet

Creating a Client JavaServer Page

Creating a Standalone Proxy

Configuring Logical Ports

Web Service Administration Using the Visual Administrator

Web Service Homepage

Web Services Security

Secure Transmission

WS Security

Authentication

Configuring Transport Authentication

Configuring Document Authentication

Authorization

Testing Java Applications

JLin

Creating and Editing Variants

Executing Tests

Results

Testing Web Dynpro Applications in the Developer Studio

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

Go and Create

Creating Your First Web Dynpro Application

Creating a Web Dynpro Project

Creating a Web Dynpro Component

Creating further Views

Specifying the Navigation Schema

Creating Actions and Implementing Navigation

Designing a View Layout

Defining Data Binding for UI Elements

Creating a Web Dynpro Application

Building, Deploying, and Running Your Application

Creating Your First J2EE Application

Creating an EJB Module Project

Developing the Calculator Session Bean

Creating the Enterprise Bean Archive

Creating a Web Module Project

Developing the JavaBean CalcProxy

Developing the Calculator.jsp

Building the Web Archive

Assembling the Calculator Application

Deploying and Running the Calculator Application

Creating a J2EE-Based Car Rental Application

Defining a Data Model

Creating a Dictionary Project

Creating a Table

Adding Table Columns

Creating an SDA

Deploying an SDA

Implementing Data Access

Creating an EJB Module Project

Creating the QuickBookingBean Entity Bean

Adding the Implementation of the ejbCreate Method

Implementing the Business Logic

Creating and Implementing Auxiliary Classes

Creating a Java Project as a Source Container

The Constants Class

The QuickBookingModel JavaBean

The Exception Class QuickCarRentalException

Exporting the JAR File

Creating the Session Bean QuickOrderProcessorBean

Implementing the Session Bean Class

Throwing the Exception QuickCarRentalException

Implementing the saveBooking() Method

Implementing the cancelBooking() Method

Implementing the viewActiveBookings() Method

Creating a JAR

Editing Deployment Descriptors

Adding Descriptions to ejb-jar.xml

Adding Descriptions to persistent.xml

Adding Descriptions to ejb-j2ee-engine.xml

Creating a Jar File

Implementing a Web Application

Creating a Web Module Project

Creating the JSP quickCarRentalView

Adding Source Code

Creating the QuickReservationServlet Servlet

Adding Source Code to the Servlet

Creating a Web Archive

Editing Deployment Descriptors

Adding Descriptions to web.xml

Creating a War File

Creating and Deploying the Complete J2EE Application

Creating an Enterprise Application Project

Editing Deployment Descriptors

Adding Descriptions to application.xml

Creating a DataSource Alias

Creating an Ear File

Deploying an EAR

Executing the Car Rental Application

Making the Car Rental Application Available as a Web Service

Creating a Web Service

Deploying the Web Service QuickCarRentalService

Creating a Web Dynpro Application Accessing ABAP Functions

Importing a Project Template

Developing the Example Application – Steps

Creating a Model

Creating a Custom Controller Context and Binding it to the Model

Mapping Custom Context Elements to View Context Elements

Creating Actions and Declaring Methods

Editing the UI Elements

Adding the Implementation of the Backend Connection

Building, Deploying, Configuring, and Running Your Application

Using the Car Rental Web Service with Web Dynpro

Importing a Project Template

Creating a Model

Creating a Component Context and Binding It to the Model

Mapping a View Context onto the Component Controller

Defining Data Binding for UI Elements

Implementing the Event Handler of the View

Building, Deploying, and Running Your Application

Creating an Email Client Using Web Dynpro and Web Services

Creating a Project Structure

Creating a Web Service Model

Creating the Binding: Component Controller Context and Model

Mapping View Context Elements to Component Context Elements

Creating the SendEmail Action

Designing a View Layout

Adding the Implementation for the Web Service Connection

Calling the Execute Method

Building, Deploying, and Running the Project

Debugging J2EE Applications

Activating Debugging

Preparations for Debugging a JSP

Debugging a JSP

Preparations for Debugging a Servlet

Debugging a Servlet

Debugging a Web Dynpro Application

Activating Debugging

Starting a Debug Session

Tutorial 2: “Development with a Track“

Tutorial 2: Development with a Track

Tutorial 2: Preparation

Creating Users and Assigning Groups

Creating a Software Component in the SLD

Creating a Domain and Track in the CMS

Checking In and Importing Required SCs

Tutorial 2: Step 0 – Importing the Development Configuration

Tutorial 2: Step 1 – Create, Locally Build, Check In a Java DC

Tutorial 2: Step 2 – Creating a J2EE Java Library DC

Tutorial 2: Step 3 – Create a J2EE Application

Tutorial 2: Step 4 – Testing and Checking In a DC

Tutorial 2: Step 5 – Activation in the CBS

Tutorial 2: Step 6 – Release Changes for Consolidation

Tutorial 2: Step 7 – Consolidate Changes

Tutorial 2: Step 8 – Create SCA (Assembly)

Tutorial 2: Step 9 – Import SCA into the Test System

Tutorial 2: Step 10 – Approve Transport

Tutorial 2: Step 11 – Import into Production System

Starting and Stopping the SAP System

Core Development Tasks

Developing User Interfaces

Web Dynpro

Portal Integration of Web Dynpro Applications

Running a Web Dynpro Application in SAP Enterprise Portal

Define a System

Creating a Web Dynpro-Based iView

Creating a Web Dynpro iView Template

Programming Portal Eventing

Subscribing to a Portal Event

Code Example for Programming Portal Eventing

Use of Portal Navigation

Navigation Between Web Dynpro Applications in the Portal

Creating a Sample Web Dynpro Project for Page Navigation

Integrating Applications in the Portal

Defining the View of the Start Application

Defining the View of the Target Application

Building, Deploying, and Running the Project

Testing and Executing Applications in the Portal

Using the Template for Portal Eventing

Use of WorkProtect Mode

Web Dynpro Clients

Web Dynpro Client for Windows

Mobile Web Dynpro

Special Features of the Nokia Series 80 Devices

Special Features of BlackBerry Wireless Handhelds

Special Features of Pocket PCs

Mobile Add-On Library

Web Dynpro BarCodeReader API – IWDBarCodeReader

Using the UI Element BarCodeReader

Web Dynpro FunctionKey API – IWDFunctionKey

Using the UI Element FunctionKey

Web Dynpro RFIDReader API – IWDRFIDReader

Using the UI Element RFIDReader

Procedures for Developing a WD Application

Designing Web Dynpro Applications

Architecture Design

Modeling Development Components

Modeling Web Dynpro Projects

Detail Design

Modeling Web Dynpro Components

Modeling Web Dynpro Windows

Setting Up a Web Dynpro Project

Developing Locally

Creating a New Web Dynpro Project

Development in a Team

Importing Development Configurations

Creating a New Web Dynpro DC

Providing Functions for Other DCs

Creating a Public Part for a DC

Including Development Objects in a Public Part

Using Functions of Other DCs

Defining Usage Dependency for a DC

Example: Using a Foreign Web Dynpro Component

Migrating Local Web Dynpro Projects

Some Rules for Working with the DTR

Creating the First Application Elements

Naming Conventions

Naming Convention for Abbreviations

Naming Conventions for Coding Entities

Creating a Project

Creating a Web Dynpro Development Component Project

Creating a Component

Copying a Component

Embedding Components

Nesting Components

Specifying the Call Sequence of Components

Referencing a Component

Creating a Window

Creating a View

Copying a View

Creating an Application

Data Retrieval

Using External Data Imported from an XMI Model

Conditions for an XMI Model Import

Importing an Adaptive RFC Model

Adaptive RFC

Reusing BAPI Data

Multiple Back End Support for the Adaptive RFC Model

Mapping Logical Systems

Security of Logical Systems

Importing a Web Service Model

Importing a JavaBean Model

Importing a WD Model of the Type JavaBean for a Local WD Project

JavaBean Model in a Development Component Project

Conditions and Naming Conventions for an Import Bean

Editing Model Classes

Referencing a Model

Defining Dictionary Data Types and Structures

Defining Currencies

Programming the User Interface and Navigation

Creating a View

Copying a View

Embedding a View in a View Set

ViewContainerUIElement API

View Templates

Using the Form Template

Using the Table Template

Using the ActionButton Template

Working with User Interface Elements

Data Binding of User Interface Element Properties

Bindable Data Types

Dynamic Metadata

Data Binding of a Dropdown List Box and Radio Button Group

Code Example of Key Binding

Data Binding of a Tree UI Element

Code Example for Creation of a Tree UI Element

Code Example of the Use of a Recursive Node

Data Binding of a BusinessGraphics UI Element

Code Example of a Complex Business Graphic Presentation

Code Example for Displaying a Gantt Chart

Code Example of the Use of a Geographical Map

Example for Displaying a Route

Example of the Use of an Interactive PDF Form

Example for the Use of an Office Document

Code Examples of Data Binding

UI Elements

Common UI Element Properties

Methods of the UI Element APIs

Layout

FlowLayout API

FlowData API

GridLayout API

GridData API

MatrixLayout API

MatrixData API

MatrixHeadData API

RowLayout API

RowData API

RowHeadData API

Containers

ScrollContainer API

Group API

TransparentContainer API

Tray API

Adobe Library

Web Dynpro InteractiveForm API - IWDInteractiveForm

Web Dynpro Form – UI Element CheckFields

Web Dynpro Form – UI Element SubmitToSAP

Web Dynpro Form – UI Element HideReaderToolbar

Example of the Use of an Interactive PDF Form

Breadcrumb Navigation

BreadCrumb API

BreadCrumbStep API

MultipleBreadCrumbStep API

Web Dynpro BusinessGraphics API - IWDBusinessGraphics

Code Example of a Complex Business Graphic Presentation

Web Dynpro Category API - IWDCategory

Web Dynpro Series API - IWDSeries

Web Dynpro Point API - IWDPoint

Web Dynpro SimpleSeries API - IWDSimpleSeries

Web Dynpro NumericValue API - IWDNumericValue

Web Dynpro TimeValue API - IWDTimeValue

Button - ButtonRow

Caption API

CheckBox API

CheckBoxGroup API

DateNavigator

DateNavigator API

DateNavigatorLegend API

DateNavigatorMarking API

DropDownByIndex API

Data Binding for DropDownByIndex Elements

DropDownByKey API

Data Binding for DropDownByKey Element

FileDownload API

Data Binding for resource Property with FileDownload and FileUpl

FileUpload API

HorizontalGutter API

Web Dynpro GeoMap API - IWDGeoMap

Code Example of the Use of a Geographical Map

Web Dynpro IFrame API – IWDIFrame

Image API

InputField API

ItemListBox API

Label API

LinkToAction API

LinkToURL API

Popup Menu

Menu API

MenuActionItem API

MenuCheckBox API

MenuRadioButton API

Web Dynpro OfficeControl API – IWDOfficeControl

PhaseIndicator

Web Dynpro PhaseIndicator API – IWDPhaseIndicator

Web Dynpro Phase API – IWDPhase

ProgressIndicator API

Web Dynpro RadioButton API - IWDRadioButton

Web Dynpro RadioButtonGroupByKey API - IWDRadioButtonGroupByKey

Web Dynpro RadioButtonGroupByIndex API - IWDRadioButtonGroupByIn

RoadMap API

RoadMapStep API

MultipleRoadMapStep API

Table

Web Dynpro Table API - IWDTable

Filtering and Sorting in a Table

TableColumnGroup API

Web Dynpro TableColumn API - IWDTableColumn

TreeByNestingTableColumn API

Cell Variants

Defining Cell Variants: TableSingleMarkableCell

TableSingleMarkableCell API

TableStandardCell API

Tabstrip

TabStrip API

Tab API

Web Dynpro TextEdit API - IWDTextEdit

TextView API

ToggleButton API

ToggleLink API

Toolbar

ToolBar API

ToolBarButton API

ToolBarButtonChoice API

ToolBarDropDownByIndex API

ToolBarDropDownByKey API

ToolBarInputField API

ToolBarLinkToAction API

ToolBarLinkToURL API

ToolBarSeparator API

ToolBarToggleButton API

Tree API

Web Dynpro TreeNodeType API - IWDTreeNodeType

Web Dynpro TreeItemType API - IWDTreeItemType

TriStateCheckBox API

ValueComparison API

Creating a Plug

Implementing Methods for Outbound Plug Calls

Creating a Link

Implementing the Data Flow

Event Handling of UI Elements

Creating an Action at Design Time

Web Dynpro Action at Runtime – Interface IWDAction

Action Types

Event Parameter and Parameter Mapping

Web Dynpro ParameterMapping API - IWDParameterMapping

Creating a Custom Controller

Copying a Custom Controller

Referencing a Custom Controller

Editing a Custom Controller

Renaming a Custom Controller

Creating a Data Link

Context Structure

Context Description

Declaration of Controller Contexts

Nodes and Node Elements

Independent and Dependent Nodes

Node Collection

Lead Selection and Node Selection

Structure Nodes and Structure Binding

Singleton and Non-Singleton Nodes

Supply Functions

Recursive Context Nodes

Context Attributes

Typing Context Attributes for Data Binding

Assignment of Dictionary Types and Java Types

Calculated Context Attribute

Context Mapping

Mapping Independent and Dependent Nodes

Mapping Context Attributes

External Context Mapping

Mapping Recursive Context Nodes

Model Binding

Providing Data Using Value Nodes and Value Attributes

Using the Service Controller

Using the Relate Context Attribute Template

Programming User Messages

Creating a User Message

Error Handling

Deploying and Executing a Web Dynpro Application

Deployment Service

Debugging a Web Dynpro Application

Activating Debugging

Starting a Debug Session

Analyzing Web Dynpro Programs

Debugging a Web Dynpro Application

Enabling Debugging on the Server

Setting Breakpoints in Web Dynpro Applications

Creating Debug Launch Configurations

Starting and Stopping Debugging

Logging

Client Tracing

Metadata Comparison for Web Dynpro Projects

Creating Your First Web Dynpro Application

Creating a Web Dynpro Project

Creating a Web Dynpro Component

Creating further Views

Specifying the Navigation Schema

Creating Actions and Implementing Navigation

Designing a View Layout

Defining Data Binding for UI Elements

Creating a Web Dynpro Application

Building, Deploying, and Running Your Application

Advanced Web Dynpro Technologies

Web Dynpro Phase Model

Administration/Configuration of Web Dynpro Runtime Environment

Web Dynpro Content Administrator

Structure of the Web Dynpro Content Administrator

Creating JCo Destinations

Maintaining JCo Destinations

Starting Assigned SLDs

Checking SLD Connections

Browse and Search Function

Activating and Deactivating Applications

Defining and Maintaining Text Mapping

Setting up a Web Dynpro Application for a Logon Ticket

Web Dynpro Console

Monitoring a Web Dynpro Archive in the Console

Performance Data Within the Request Response Cycle

Display of Performance Data for the Web Dynpro Framework

Determination of Performance Data for Clients

Obtaining Performance Data About the Standard Client

Measuring the Performance of Web Dynpro Applications

Display of Performance Data for Requests

Display of Performance Data for the Model or Backend

Display of Performance Data for Users

Web Dynpro-Specific URL Parameters

URL Generation Service

Configuring the Destination URL for the Adobe Document Services

Availability Monitoring for Web Dynpro Applications

Configuring the Web Dynpro Runtime Environment

Using Runtime Services

Implementing the Server Abstraction Layer

Deployment Service

Configuration Service

Configuring the Web Dynpro Runtime Environment

Configuring a Web Dynpro Application

Setting Values of the Application Properties

Using LogoffURL for Redirection After Terminating the Applicatio

User Management Service

Internationalization Service

URL Generation Service

Services for the SAP System Landscape Directory and SAP Java Con

Context Description

Declaration of Controller Contexts

Nodes and Node Elements

Independent and Dependent Nodes

Node Collection

Lead Selection and Node Selection

Structure Nodes and Structure Binding

Singleton and Non-Singleton Nodes

Supply Functions

Recursive Context Nodes

Context Attributes

Typing Context Attributes for Data Binding

Assignment of Dictionary Types and Java Types

Calculated Context Attribute

Context Mapping

Mapping Independent and Dependent Nodes

Mapping Context Attributes

External Context Mapping

Mapping Recursive Context Nodes

Event Handling of UI Elements

Creating an Action at Design Time

Web Dynpro Action at Runtime – Interface IWDAction

Action Types

Event Parameter and Parameter Mapping

Web Dynpro ParameterMapping API - IWDParameterMapping

Error Handling

Messages

Processing a Message

Example for Using Messages

Development of Interactive Adobe Forms for the Web Dynpro UI

Adobe Library

Configuring the Destination URL for the Adobe Document Services

Internationalization of Web Dynpro Projects

Internationalization Concepts for a Web Dynpro Project

Translation of the Texts

Creating Language-Dependent Resources at Design Time

Messages

Processing a Message

Search Process for Determining the Required Resource Bundle

Internationalization Service

Dynamic UI Generation

Other Tutorials

Basic Tutorials

Creating Your First Web Dynpro Application

Creating a Web Dynpro Project

Creating a Web Dynpro Component

Creating further Views

Specifying the Navigation Schema

Creating Actions and Implementing Navigation

Designing a View Layout

Defining Data Binding for UI Elements

Creating a Web Dynpro Application

Building, Deploying, and Running Your Application

Creating a Simple Web Dynpro Application

Creating a Web Dynpro Project

Creating a Web Dynpro Component

Creating and Designing a View

Defining a Web Dynpro Window

Defining a Web Dynpro Application

Deploying a Web Dynpro Project

Calling a Web Dynpro Application

Displaying the Current Date Using Data Binding

Structure of a Web Dynpro Application

Creating an Extended Web Dynpro Application

Quiz Application

Creating the First Parts of the Application

View Modeling and User Interface Layout

Determining the Content and Interaction of Views

Defining a View Composition

Implementing the View Composition

Designing a View Layout

Using the ActionButton Template

Creating Navigation Transitions

Controller Contexts and Data Binding

Defining Controller Contexts

Defining Data Binding

Context Programming

Adding QuizData Node Elements in Context Nodes

Initializing Top Level Value Attributes

Programming Context State Changes

Portal Integration of the Web Dynpro Application

A Simple Input Form

Application Example for Displaying Messages

Specifying the Project Structure

Declarative Development of a View

Defining Simple Type Data Types in the Java Dictionary

Developing the Form View

Developing the EMailEditor View

Defining the navigation structure

Defining Messages

Implementing the View Controller

Implementing the Controller of the Form View

Implementing the Controller of the EMailEditor View

Advanced Tutorials

Model Tutorials

Creating a Web Dynpro Application Accessing ABAP Functions

Importing a Project Template

Developing the Example Application – Steps

Creating a Model

Creating a Custom Controller Context and Binding it to the Model

Mapping Custom Context Elements to View Context Elements

Creating Actions and Declaring Methods

Editing the UI Elements

Adding the Implementation of the Backend Connection

Building, Deploying, Configuring, and Running Your Application

Creating an Email Client Using Web Dynpro and Web Services

Creating a Project Structure

Creating a Web Service Model

Creating the Binding: Component Controller Context and Model

Mapping View Context Elements to Component Context Elements

Creating the SendEmail Action

Designing a View Layout

Adding the Implementation for the Web Service Connection

Calling the Execute Method

Building, Deploying, and Running the Project

Using the Car Rental Web Service with Web Dynpro

Importing a Project Template

Creating a Model

Creating a Component Context and Binding It to the Model

Mapping a View Context onto the Component Controller

Defining Data Binding for UI Elements

Implementing the Event Handler of the View

Building, Deploying, and Running Your Application

Context Tutorials

Application of Context Programming and Data Binding

The Master/Detail Viewer Application

Specifying the Project Structure

Context Design in the Master/Detail Viewer

Declaring the Controller Context of a View

Designing a View Layout

Binding Tables to the Controller Context of a View

Implementing the Controller Context of a View

Implementing a Demo BOL

Initializing the Controller Context of a View

Adding a Supply Function

User Interface Tutorials

Tutorial: Developing with Tables in Web Dynpro

Importing the Project Template

Creating the Component Controller Context

Mapping the View Context onto the Component Controller Context

Enhancing the View Context

Creating the Table

Binding the Table to the Context

Creating and Binding the Detailed Form

Deleting Single or Several Rows

Sorting

Calculating the Total per Article

Calculating the Total

Setting and Changing the Currency

Building, Deploying, and Running the Table Tutorial

Constructing a Recursive and Loadable Web Dynpro Tree

Importing a Project Template

Recursive Context Nodes

Further Procedure for Creating the Web Dynpro Tree

Creating the Context for the TreeView

Creating Actions for the Tree

Creating UI Elements

Creating a Resource Bundle for the File Structure

Initialising the Context

Mapping the Event Parameters

Event Handling: Expanding a Node

Event Handling: Selecting an Entry

Building, Deploying, and Running the Project

Dialog Boxes in Web Dynpro Applications

Importing a Project Template

Creating an External Window

Creating a Dialog Box

Creating a Web Dynpro Window for the Address Book

Interaction of the EmailWindow and the AddressbookWindow

Creating a Confirmation Dialog Box

Executing the Complete Application

Value Help in Web Dynpro Applications

Example Application of a Value Selector

Simple Value Selector

Specifying the Project Structure

Inserting a Simple Value Selector

Including an Extended Value Selector

Modeling View Compositions in Web Dynpro

Importing a Project Template

Developing the Example Application for a View Composition

Adding the ViewContainerUIElement

Embedding a View Set in a ViewContainerUIElement

Using ViewContainerUIElements

Using a Web Dynpro Component

Embedding an Inner View Set

Embedding Component Interface Views in a View Set

Controlling the Lifecycle of a Component Instance

Component Tutorials

Using Server-Side Eventing in Web Dynpro Components

Eventing Example Application

Creating a Project Structure

Implementing the View Composition

Developing the Internal Web Dynpro Component

Declaring Event and Method in the Interface Controller

Setting Declarations in the Form View Controller

Designing the Layout of the Form View

Implementing Form View Controller and Interface Controller

Developing the Web Dynpro Component

Setting Declarations in the ControlPanel View Controller

Designing the Layout of the ControlPanel View

Implementing the Controller of the ControlPanel View

Using External Context Mapping

Special Tutorials

Portal Tutorials

Running a Web Dynpro Application in SAP Enterprise Portal

Define a System

Creating a Web Dynpro-Based iView

Creating a Web Dynpro iView Template

Programming Portal Eventing

Subscribing to a Portal Event

Code Example for Programming Portal Eventing

Navigation Between Web Dynpro Applications in the Portal

Creating a Sample Web Dynpro Project for Page Navigation

Integrating Applications in the Portal

Defining the View of the Start Application

Defining the View of the Target Application

Building, Deploying, and Running the Project

Testing and Executing Applications in the Portal

Object-Based Navigation Between Web Dynpro Applications (OBN)

Integrating Web Dynpro Applications into the Portal

Importing a Business Object

Creating a Business Object Operation

Assigning Business Object Operations to the iView

Defining the User Interface Element DropDownBoxByIndex

Providing Services

Defining Authentication

Creating a Reference to the IUserObjectBasedNavigation Service

Implementing the Source Code for the View

Defining Parameter Transfer

Filling the Context Attributes with Data

Result of the Web Dynpro OBN Tutorial

Developing International Web Dynpro Applications

Importing a Project Template

Creating Texts for the Original Language

Creating the Simple Types

Create the context and action

Completing the Layout of the Application

Creating a Warning Message and Implementing onActionRent()

Create dynamic texts and complete the application

Translating Text Resources into Other Languages

Define language-specific application properties

Executing and Testing the Application

User Interface Tutorials

Using Business Graphics

Carrying Out the Initial Steps

Inserting a Business Graphic in the View

Editing the Properties for the UI Element

Editing the Context for the View

Changing Type Property of Data Series

Binding the Data

Supplying the Context with Data

Building, Deploying and Running the Project

Using Geo Services With Web Dynpro

Overview on Geo Services and IGS

Importing a Project Template

Create the Example Application “Using Geo Services“

Extend the Context of the GeoServiceView

Extend the Layout of the GeoServiceView

Implement the Action Handler onActionShowRoute

Zooming In

Execute the Application Tutorial_GeoServices

Debugging Tutorials

Debugging a Web Dynpro Application

Activating Debugging

Starting a Debug Session

Debugging ABAP Code from Within the Developer Studio

Dynamic UI Generation in Web Dynpro

Importing a Project Template

Overview of Dynamic Programming in the Web Dynpro

Creating Dynamic User Interface Elements

Dynamically Building the Appropriate Context

Dynamically Creating the Form

Dynamically Creating Pushbuttons with Appropriate Actions

Action Handling

Executing the Application TutWD_Dynamic_Init

Protecting Access to the Web Dynpro Application Using UME Permis

Concepts Necessary for Using UME Permissions with this Tutorial

Authentication Between the Components Using Logon Tickets

Permissions, Actions, and UME Roles

Permission Class for Your Application

actions.xml File

UME Archive File

Importing the Project Templates for the Web Dynpro Tutorial

Integrating UME Permissions in the Web Dynpro Application - Step

Including the UME Libraries and Web Service References

Specifying Authentication for the Application

Specifying Authentication for Access to the Web Dynpro Client

Specifying Authentication for Access to the Web Service

Creating the HTTP Destination

Using the HTTP Destination Within the Web Dynpro

Protecting Access to the EJB Methods Using UME Permissions

Creating the Permission Class for the EJB Methods

Obtaining the User ID from the Context

Checking the Permission in the EJB Methods

Adjusting the Message Handling

Rebuilding the Projects and Redeploying the Application

Defining Actions in the actions.xml File

Build and Deploy the Archive File

Creating the Users

Creating UME Roles

Assigning Users to the Roles

Testing the Access Protection

Checking Permissions in the Web Dynpro Frontend Client

Including the UME JAR File in the Web Dynpro Project

Creating the Permission Class for the Web Dynpro

Checking the Permission in the Web Dynpro Client

Rebuilding and Redeploying the Project

Defining Actions for the Web Dynpro Project

Modifying the UME Roles and User Assignments

Testing the Access Protection

Web Dynpro Tools

Controller/Context Editor

Context Structure

Model Binding

Providing Data Using Value Nodes and Value Attributes

Data Modeler

Creating a Data Link

View Templates

Using the Form Template

Using the Table Template

Using the ActionButton Template

Using the Service Controller

Using the Relate Context Attribute Template

Message Editor

Creating a User Message

Navigation Modeler

Creating a View

Creating a View Set

Embedding a View in a View Set

Creating a Plug

Creating a Link

View Designer

Working with User Interface Elements

The User Interface Element Container

Chart Designer

Calling the Chart Designer

Web Dynpro Explorer

Creating a Project

Creating a Web Dynpro Development Component Project

Web Dynpro Class File Minimizer

Importing a Project

Deleting a Project

Navigator

Web Dynpro Model Tools

Importing an Adaptive RFC Model

Adaptive RFC

Reusing BAPI Data

Multiple Back End Support for the Adaptive RFC Model

Importing a Web Service Model

Importing a JavaBean Model

Using External Data Imported from an XMI Model

Conditions for an XMI Model Import

Referencing a Model

J2EE Web Applications

J2EE Application Concepts

Web Container

J2EE Web Application

Web Components

Servlet Life-cycle

JSP Life-cycle

Objects of Scope

Hints on Designing J2EE Web Applications

Developing J2EE Web Applications

Creating Web Projects

Developing Servlets

Creating Servlets

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

J2EE Engine 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 JSP Pages

Creating JSP Files

JSP Syntax Elements Outline

Implicit Variables

Using the page Directive

Using the taglib and include Directives

Including and Forwarding Requests in a JSP

Using Declarations

Using Scriptlets

Developing Custom JSP Tag Libraries

Implementing Tag Handlers

Describing the Tag Library

Using a Custom Tag in a JSP Page

Developing Filters

Initializing Filters

Filtering Requests or Responses

J2EE Web Applications Security

Authentication for Web Applications Users on the J2EE Engine

Overview of the Login Process in JAAS

Using Login Modules to Protect Web Applications

SAP Specific HTTP Callbacks

Changing the User Password

Security Sessions

Authorization for Web Application Users on the J2EE Engine

Single Sign-on for J2EE Web Applications

Propagation of Security Principals to Other Containers on the J2

Building WARs

J2EE Web Components Configuration

Specifying Web Application Display Information

Declaring and Configuring Web Components

Defining Servlet Context Parameters

Mapping Servlets and JSP Pages

Mapping Filters

Setting up the Application Operational Environment

Configuring Environment Entries

Configuring Resource Environment Entries

Configuring Resource References

Configuring Enterprise Bean References

Defining Server Component References

Configuring Web Applications Security

Specifying Security Constraints

Defining Web Application Security Roles

Configuring Authentication

Configuring the J2EE Engine Cookies

Limiting the Number of HTTP Sessions

Custom Error Pages

Configuring Custom Error Response Pages

Defining Custom HTTP Response Status Codes

Configuring JSP Tag Libraries

Configuring Failover Alert

Configuring Welcome Pages

Configuring Session Tracking with URL Rewriting Only

Specifying HTTP Session Timeout

Default Configurations of the Web Container

Editing the Global Deployment Descriptors

Default Implementation of HTTP PUT Method

Providing Long-lived Request and Response Objects

JSP Servlet

Invoker Servlet

Default Servlet

PasswordChangeForm Servlet

Creating Enterprise Projects

Building EARs

Deploying EARs

Metadata Comparison Tool

Developing Business Logic

Developing Enterprise Beans

Introduction to Enterprise Beans

Enterprise Bean Structure

J2EE Engine EJB Architecture

Developing an EJB Application

Creating EJB Projects

Developing Session Beans

Stateful or Stateless Session Beans

Creating Stateless Session Beans

Creating Stateful Session Beans

Creating and Editing the Enterprise Beans' Methods

Creating and Editing the Deployment Descriptors

Setting the EJB JAR Properties

Specifying Bean-Specific Properties

Declaring Environment Entries

Declaring EJB References

Declaring Resource References

Defining Transaction Attributes

Specifying Arbitrary JNDI Names for Your Beans

Specifying the Bean’s Container Size

Specifying JNDI Names for the Beans References

Specifying References to Objects Bound in the JNDI

Stateful Session Beans' Timeouts

Specifying Stateful Session Beans' Timeouts

Developing Entity Beans

Bean-Managed or Container-Managed Entity Beans

Creating Entity Beans

Creating and Editing the Enterprise Beans' Methods

Creating the Bean's Persistent Fields

Creating Primary Keys

Creating Dependent-Value Persistent Fields

Container-Managed Relationships

Creating Beans' Relationships

Defining Relationships Between Container-Managed Entity Beans

Mapping Relationships

Creating and Editing the Deployment Descriptors

Setting the EJB JAR Properties

Specifying Bean-Specific Properties

Declaring Environment Entries

Declaring EJB References

Declaring Resource References

Specifying the Deployment Properties of Finder/Select Queries

Defining Transaction Attributes

Specifying Arbitrary JNDI Names for Your Beans

Specifying the Bean’s Container Size

Specifying the Initial Cache Size of the Persistence Manager

Specifying Primary Key Deployment Properties

Specifying JNDI Names for the Beans References

Specifying the Data Source and the Database Vendor

Specifying References to Objects Bound in the JNDI

Locking

Choosing the Type of Enqueue Server Locking

Isolation Levels

Enabling Database Locking

Database Mapping

Mapping Entity Beans to Database Tables

Mapping Persistent Fields (cmp-fields)

Mapping Relationships

Verifying the Object/Relational Mapping

Database Types

Object/Relational Mapping Rules

Optimizations and Performance Tuning

Defining Entity Beans as Read-Only

Developing Message-Driven Beans

Creating Message-Driven Beans

Creating and Editing the Deployment Descriptors

Setting the EJB JAR Properties

Specifying Bean-Specific Properties

Declaring Environment Entries

Declaring EJB References

Declaring Resource References

Defining Transaction Attributes

Specifying Arbitrary JNDI Names for Your Beans

Specifying JNDI Names for the Beans References

Configuring Message-Driven Bean Specific Properties

Specifying References to Objects Bound in the JNDI

Message-Driven Bean Example

Pool Properties

Specifying the Pool Properties

Security for Enterprise Beans

Defining Security Roles

Mapping Security Roles

Specifying Permissions for Method Invocations

Declaring Security Role References

Specifying Security Identity

Specifying Security When Using IIOP

Failover for Enterprise Beans

Enabling and Disabling HTTP Failover

Enabling Stateful Session Failover

Specifying the Failover Persistent Storage

Enterprise Bean Clients

Looking Up Enterprise Beans

Building EJB JARs

Creating Enterprise Projects

Building EARs

Deploying EARs

Configuring Enterprise Beans After Deployment

Java Messaging

Developing JMS Applications

Creating a JMS Connection

Point-to-Point Model

Creating a Message Producer to a Queue

Creating a Message Consumer to a Queue

Creating Temporary Queues

Queue Sender and Receiver

Message Delivery Attempts Limitation

Publish-Subscribe Model

Creating Message Producer to a Topic

Creating Message Consumer to a Topic

Asynchronously Receiving Messages Sent to a Topic

Synchronously Receiving Messages Sent to a Topic

Managing Durable Subscriptions

Creating Message Selector

JMS Messages

Unpacking the Received Messages

Message Acknowledgement

Security on JMS Service

Closing the JMS Connection

Developing Message-Driven Beans

Creating Message-Driven Beans

Creating and Editing the Deployment Descriptors

Setting the EJB JAR Properties

Specifying Bean-Specific Properties

Declaring Environment Entries

Declaring EJB References

Declaring Resource References

Defining Transaction Attributes

Specifying Arbitrary JNDI Names for Your Beans

Specifying JNDI Names for the Beans References

Configuring Message-Driven Bean Specific Properties

Specifying References to Objects Bound in the JNDI

Message-Driven Bean Example

Integrating an External JMS Provider

Naming (JNDI)

JNDI Registry Service Specific Features

J2EE Engine Specific Environment Parameters

Creating an InitialContext

Integration with Other Services

Developing Application Clients

Performing Lookup from Application Client

Packaging and Deploying Application Client

Developing Java Persistence

Java Persistence Infrastructure

Table Buffer

Buffer Granularity

Statements Using the Buffer

Statements Bypassing the Buffer

Modifications and Actions on the Remote Buffers

Buffering Hints

SQL Trace

Launching the SQL Trace

Activating and Deactivating SQL Trace

Evaluating the SQL Trace

SQL Trace Filtering

SQL Trace File Administration

Statement Pooling

Java Dictionary

Modifying Dictionary Preferences

Development Process

Creating Data Types

Initial Values

Creating Structures

Reference Fields

Tables

Creating Tables

Buffering Type

Creating Indexes

Deploying Tables

Editing Table Definitions

Connectivity

Using the Default DataSource

Registering a DataSource Alias

Creating a DataSource

Reconnecting to the DB in Case of DB Crash

Relational Persistence

Getting Started with Relational Persistence

Creating the Database Tables

Creating the Web Project

Developing the EmployeeData Class

Developing the Data Access Interface

Creating the SQLJ Connection Context

Creating an SQLJ ResultSet Iterator

Implementing the Data Access Interface with SQLJ

Implementing the Data Access Interface with JDBC

Developing the Web Front End

Assembling the Application

Deploying and Running the Application

Open SQL/JDBC

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

Open SQL/SQLJ

Syntax Overview

Creating and Editing SQLJ Sources

Database Connection Context

Execution Context

Host Variables and Host Expressions

DML Statements

ResultSet Iterators

Single-Row Query

Handling NULL Values

SQLJ Batching

Combining SQLJ and JDBC

Transactions in Open SQL/SQLJ

Using the SQLJ Checker

Debugging SQLJ Sources

Open SQL Grammar

Open SQL Data Types

Character Strings

Binary Strings

Using LOBs

Reading and Writing LOBs En Bloc

Using Locators

Using Streams

Numbers

Datetime Values

Object Persistence for Java

Enterprise Entity Beans

Java Data Objects (JDO)

Getting Started with JDO

Creating the Database Tables

Creating the Web Project

Defining the Persistence Capable Classes

Defining the Object Identity Classes

Defining the JDO Metadata

Defining the O/R Mapping

Running the JDO Enhancer and Checker Tools

Implementing the Business Logic

Developing the Web Front End

Assembling the Application

Deploying and Running the Application

Architecture Overview

Supported Options in the SAP JDO Implementation

The Default PersistenceManagerFactory

Persistence Capable Classes

JDO Life Cycle and State Transitions

JDO Enhancement

JDO Metadata

Mapping Persistent Classes to Database Tables

Mapping Primitive Fields

Mapping Relationship Fields

Bidirectional, Inverse and Managed Relationships

One-to-Many Bidirectional Relationships

One-to-many Unidirectional Relationships

Many-to-One Unidirectional Relationships

Many-to-Many Bidirectional Relationships

Many-to-Many Unidirectional Relationships

One-to-One Bidirectional Relationships

One-to-One Unidirectional Relationships

Null Values

Foreign Key Constraints

Multiset Semantics/Collections

Mapping Relationship Fields with Generic Types

Many-to-One Unidirectional Generic Relationships

One-to-One Unidirectional Generic Relationships

Many-to-Many Unidirectional Generic Relationships

One-to-Many Unidirectional Generic Relationships

Inheritance Mapping

Mapping to One Table

Mapping to Separate Tables

Type Mapping

The JDO Query Language

Constructing and Executing Queries

Extent

Working with Persistent Objects

Transactions in JDO

Locking

JDO Programming Models

Using JDO with Session Beans

Using JDO with Message-Driven Beans

Using JDO with BMP Entity Beans

Using JDO with Web Components

Combining JDO and JDBC

JDO Reference

JDO State Checks

JDO State Transitions

JDOQL Operators

JDO Mapping Metadata DTD

Transactions and Resource Handling

Introduction to Transactions in J2EE Engine

JTA Implementation

JTS Implementation

JTA and Local Transactions

Using Container-Managed JTA Transactions

Using Component-Managed JTA Transactions

Using Local Transactions

Two-Phase Commit

Resource Handling Mechanism

Connection Handling in JTA and Local Transactions

Sharing Connections

Database Connection Management

Locks

Logical Locks

Working with Locks

Setting Locks

Releasing Locks

Providing and Consuming Web Services

Web Service Toolset

Web Service Perspective

Creating a Web Service

The Development Process

Creating a Web Service for an Enterprise JavaBean

Web Service Creation Wizard

Creating a Virtual Interface

Creating a Web Service Definition

Creating a Web Service and a Web Service Configuration

Creating a Web Service for a Java Class

Creating a Web Service from a Portal Service

Web Service Navigator

Advanced Techniques

Creating a Web Service with Attachments

Maintaining SOAP Extensions

Consuming a Web Service

Creating a Deployable Proxy

Creating a Client Bean

Creating a Client Servlet

Creating a Client JavaServer Page

Creating a Standalone Proxy

Configuring Logical Ports

Web Service Administration Using the Visual Administrator

Web Service Homepage

Web Services Security

Secure Transmission

WS Security

Authentication

Configuring Transport Authentication

Configuring Document Authentication

Authorization

Web Dynpro and Web Services

UDDI

Configuring the UDDI Client and UDDI Server

Creating Business Entities

Publishing a Web Service as a Business Service

Publishing a Web Service Definition as a tModel

Creating a Web Service Client

Querying UDDI

Changing the Database of the UDDI Server

Web Services Framework

Web Service Invocation (Server-Side)

Web Service Invocation (Client-Side)

Web Service Clients Development

Service Interface

Deployable versus Standalone Proxies

Logical Ports

Service Endpoint Interface

Programming a Web Service Client Application

Security Protocol

SOAP Headers Protocol

Session Protocol

Appendix

Restrictions for WS Endpoints

Writing ABAP-Compliant Web Services

Setting up an SLD Test Server

Integrating Security Functions

Authentication for Web Applications Users on the J2EE Engine

Overview of the Login Process in JAAS

Using Login Modules to Protect Web Applications

Create and Configure a Login Module

Creating a New Java Project

Implementing the Login Module

Setting the Classpath and Compiling the Java Project

Exporting the Login Module Class in a JAR File

Creating a New Library Project

Making Reference to the Security Provider Service

Setting the Classpath to the JAR of the Login Module

Making Reference to the JAR File

Building SDA File

Deploying the SDA to the J2EE Engine

Configuring the Login Module on the J2EE Engine

Configuring the Login Module Usage

Adding a Reference to the Classloader of the Security Provider

Configuring an Application to Use the Login Module

Example Login Module

Login Modules Over HTTP

SAP Specific HTTP Callbacks

Using the HTTP Callback Classes

Changing the User Password

Single Sign-on for J2EE Web Applications

Propagation of Security Principals to Other Containers on the J2

Integration of SAP J2EE Engine and UME Authentication

Remote Authentication

Security Sessions

Obtaining the Current Security Session

Using Security Roles or UME Permissions in Applications

Security Roles

Architecture of Security Roles

Permissions, Actions, and UME Roles

Tutorials for Using Roles and Permissions in Applications

Overview of the Tutorials

Protecting Access to a J2EE-Based Application Using J2EE Securit

Protecting Access to a J2EE-Based Application Using UME Permissi

Protecting Access to the Web Dynpro Application Using UME Permis

User Management Engine

SAP Web AS Java

Authentication

SAP Enterprise Portal

LoginModule Example

Customized Password Authentication

Customized Authentication Implementation

Configure the Portal for Customized Authentication

Changing the Logon Screen

Advanced Authentication Example

User

Service User

Role

Group

Searching for Users, Roles and Groups

User Mapping

Access Control List (ACL)

Security Methods to Use for Applications

Security Aspects of Web Dynpro for Java

Digital Signatures and Document Encryption API

Interfaces and Classes for Using Digital Signatures and Encrypti

Examples for Using Digital Signatures

Secure Connection Factory API for HTTPS Clients

Interfaces and Classes for Using the Secure Connection Factory

Examples for Using the Secure Connection Factory

Destination Service API

Interfaces and Classes for Using the Destination Service API

Examples for Using the Destination Service API

Internationalization in the SAP NetWeaver Developer Studio

Internationalization of Java Projects

Externalizing Strings

Using the S2X Document Editor

Internationalization of Web Dynpro Projects

Internationalization Concepts for a Web Dynpro Project

Translation of the Texts

Creating Language-Dependent Resources at Design Time

Messages

Processing a Message

Search Process for Determining the Required Resource Bundle

Internationalization Service

Monitoring and Management

Administration

JMX Service Interface

Architecture

Writing MBeans

Connecting to an MBeanServer

MBean Registration

Access to an MBean

Query MBeans

Receiving Notifications

JMX Client Structure

Administration Adapter Service

Java Application Monitoring

Monitoring Framework

Monitors Inside the Monitoring Tree

Monitoring Resources with the Monitoring Framework

The monitor-configuration.xml

Template Monitors

Using Template Monitors

Instrumenting an Application to Provide Monitoring Data

Acquiring a Reference to the MBean Server

Building ObjectName(s) for the Resource MBean(s)

Registering the MBean

Sending Monitoring Data Actively Via JMX Notifications

Instrumenting the Application

Example of Application Instrumented with Monitoring

Designating the Variables You Want to Monitor

Developing the Resource MBean and the monitor-configuration.xml

Creating the Bank Name Text Monitor

Creating the Bank Information Configuration Monitor

Creating the Bank Rank State Monitor

Creating the Counter Desks Table Monitor

Creating the Software Version Version Monitor

Creating the Open for Clients Availability Monitor

Creating the Served Clients Long Monitor

Creating the All Clients Integer Monitor

Creating the Transaction Frequency Frequency Monitor

Creating the Transactions Over 10,000 EUR Quality-Rate Monitor

Creating the Transaction Duration Duration Monitor

Dynamically Installed Monitors

Installing the Template

Installing the Template-Based Monitors

Registering the MBean

Assigning Administrator Permissions

A Programmatic Interface that Creates and Installs Monitors Dyna

Configuration Groups

Simple Configuration Group

Configuration Configuration Group

Text Configuration Group

Version Configuration Group

Table Configuration Group

Duration Configuration Group

Frequency Configuration Group

Integer Configuration Group

Long Configuration Group

Quality-Rate Configuration Group

State Configuration Group

Summary Nodes, Object Nodes and Monitors

Installation of Summary and Object Nodes

Installation of Monitors

Installation of Table and State Monitors

Uninstallation of Summary Nodes, Object Nodes, and Monitors

Customization of Configuration Groups Using Third-Party Tools

Retrieving Monitoring Data from an External Client via JMX

Performance Monitors and Their Methods

Non-Performance Monitors and Their Methods

Using the Generic Configuration Reporter

Types of Monitors and Their Usage

Availability Monitor

Integer Monitor

Long Monitor

Frequency Monitor

Quality-Rate Monitor

Duration Monitor

Text Monitor

State Monitor

Table Monitor

Version Monitor

Configuration Monitor

Connectivity and Interoperability

SAP Java Connector

SAP JCo Architecture (Standalone Version)

SAP JCo Functions

SAP JCo Scenario: Java/ABAP Communication in SAP Web AS

SAP Enterprise Connector

Programming Model

Proxy Generation

Example: Using Generated Proxies to Call Function Modules

SAP Java Resource Adapter

SAP JRA Architecture

J2EE Connector Architecture

Implementing A 1.0 Resource Adapter

Implementing Connection Management

Implementing Transaction Support

Implementing Security Functions

Implementing Interaction Functions

Deploying the Resource Adapter

Resource Adapter Archive (RAR)

ManagedConnectionFactory Configuration

Resource Adapter Transaction Support

Resource Adapter Security

Connection Pooling

Resource Adapter Classloading

Using Resource Adapter to Obtain a Connection

Driving an Interaction with the EIS

RMI-P4

The Distributed Object Model

Characteristics of a Remote Object

RMI-P4 System Overview

The RMI-P4 Object Broker

Remote Objects Communication in RMI-P4

Garbage Collection of Remote Objects

Load Balancing of Client RMI-P4 Requests

Failover for Clustered RMI-P4 Remote Objects

Develop RMI-P4 Applications

Defining a Remote Interface

Implementing the Remote Interface

Binding the Implementation to the Naming System

Generating Stubs and Skeletons

Implementing a Client

Implementing a Client That Invokes an Enterprise Bean

Using P4 Protocol Over a Secure Connection

RMI-P4 Specific InitialContext Properties

RMI-IIOP

Developing RMI-IIOP Applications

Developing RMI-IIOP Applications with Java Remote Clients

Generating Stubs and Ties

RMI-IIOP Client That Invokes an Enterprise JavaBean

Developing RMI-IIOP Applications with CORBA Clients

Developing an RMI-IIOP Callback Application

Defining the Callback Object

Developing the UtilCallback Enterprise Bean

Generating Stub for the Notificator Object

Importing the Stub to the UtilCallback Project

Assembling the Callback Application

Deploying the Callback Application on the J2EE Engine

Developing the Client-side Application

Developing the Client Application in Java

Generating IDL Representation of the Notificator Callback Object

Generating Support Classes Based on the Notificator.idl

Importing the Support Classes to a Developer Studio Project

Implementing the Callback Object

Developing the Remote Client

Developing the Client Application in C++

Generating IDL Representation of the Callback Application

Generating C++ Code for the Notificator Object

Generating C++ Code for the Rest of the CallbackApplication Clas

Implementing the Callback Object

Developing the Client

Running the Application

Deployment: Putting It All Together

Software Deployment Manager

SDM Modes

Changing SDM Modes

Starting and Stopping the Software Deployment Manager

Starting and Stopping the SDM (Windows)

Starting and Stopping the SDM (UNIX)

Using SDM GUI

SDM Repository

Deployment

Undeploying Components

Log Viewer

SDM Troubleshooting

Deploy Tool

Getting Started

Project Creation

Deploy Tool Tabbed Panes

Setting the Deploy Tool Properties

Setting a Project Classpath

Setting Classpath Variables

Refreshing the Deploy Tool

Removing a Component

File Chooser Window

Viewing Logs

Error Reporting

Shortcut Keys

Generating J2EE Components

EJB JAR Preparation

Loading an EJB JAR

Loading an Enterprise Bean

EJB JAR Properties Management

Managing Files and Directories

Editing the Security Properties of an EJB JAR

Editing the Transaction Properties of an EJB JAR

Editing the Relation Properties of an EJB JAR

Editing the Additional Properties

Enterprise Bean Properties Management

Editing the General Settings of an Enterprise Bean

Editing the Security Properties of an Enterprise Bean

Editing the Environment and Resource Entries

Editing the Additional Properties

Editing the Storage Properties of an Enterprise Bean

Generating an EJB JAR File Without Enterprise Bean Class Files

Web Archive Preparation

Loading a Web Archive

Web Archive Properties Management

Managing Files and Directories

Editing the Main Properties

Editing the Security Properties

Editing the Pages Properties

Editing the Tag Libraries

Editing the Environment and Resource Entries

Editing the Mapping Properties

Editing the Additional Properties

Web Component Addition

New Servlet or JSP Addition

Editing the Properties of a New Servlet/JSP

Loading a Servlet or JSP from Files

Adding a Listener

Filter Addition

Editing the Properties of a Filter

Resource Adapter Preparation

Loading a Resource Adapter

Resource Adapter Properties Management

Managing Files and Directories

Editing the General Properties

Editing the Security Properties

Editing the Configuration Properties

Editing the Additional Properties

Application Client Archive Preparation

Loading an Application Client Archive

Application Client Properties Management

Managing Files and Directories

Editing the Environment and Resource Entries

Editing the Additional Properties

Making an Application Component Archive

Assembling a J2EE Application

Adding and Removing a Component Archive to an Application

Editing the Properties of an Archive

EAR Properties Management

Archive Descriptors Management

Editing the Descriptor Properties

Managing Files and Directories

Renaming an EAR

Making an EAR

Deploying, Updating and Undeploying a J2EE Application

Loading, Unloading and Refreshing an Application

Loading a J2EE Application Component

Application Deployment Properties Management

EAR Descriptor Properties Management

Editing the Context Properties of an EAR

Editing the Security Properties of an EAR

Editing the Extra Information Properties of an EAR

Editing the Additional Properties

Editing the Log Configuration Properties of an EAR

Editing the JMS Connectivity Properties of an EAR

Editing the DataSource Properties

Editing the DataSource Aliases Properties

J2EE Components Deployment Properties Management

EJB Archive Properties Management

EJB JAR Properties Management

Editing the EJB JAR Persistent Mappings

Bean Properties Management

Editing the EJB Properties of an Enterprise Bean

Editing the Persistent Properties of an Enterprise Bean

Web Archive Properties Management

Editing the WAR Context Root Properties

WAR Main Properties Management

Editing the WAR Cookie Configuration Properties

WAR Security Properties Management

Editing the Server Configuration Properties

Resource Adapter Properties Management

Editing the Server Settings of a Resource Adapter

Editing the Substitution Properties

Getting a Deployable EAR

Deploy, Update and Undeploy

Setting the Deploy Tool Deployment Properties

Deploying a J2EE Application and J2EE Application Component

Updating a J2EE Application

Updating a Single File

Deploy a Bean Application That Does Not Contain Class Files

Undeploying a J2EE Application

Deploying and Undeploying Libraries, Interfaces and Services

Loading a Library, an Interface or a Service

Editing the Properties of Libraries, Interfaces and Services

Servers and Dispatchers Properties Management

Editing the Deployment Properties of Libraries and Interfaces

Editing the Deployment Properties of a Service

Making Server Component Archives

Deploying Libraries

Undeploying Libraries

Script Files

Converter Tool

SAP NetWeaver Development Infrastructure

Development Scenarios with the NWDI

Scenario ”Java Projects with Central Source File Storage”

Scenario “Developing Components with the NWDI”

“Layered Development”

Automated Deployment into Multiple Production Systems

Application Maintenance with NWDI

Modifications and Comparison with SPs Using the NWDI

Development Landscape for Mixed Applications

Planning Considerations for Transporting Mixed Applications

Configuration of the System Landscape

Development Flow

Synchronous Transport of Mixed Applications

Configuring the NWDI User Management

Roles in the Component Build Service

Authorizations in Change Management Service

Roles in the Change Management Service

Track-Specific Authorizations

Editing Track-Specific Authorizations

User Authentication and User Authorization in the DTR

User Authentication

User Authorization in the Design Time Repository

Privileges

Granting Privileges

Groups in DTR

Access Control Lists (ACL) in the DTR

User Management Steps After Installation

Granting Initial Privileges

Editing the Emergency User

Authorizations for the DTR Client

Configuration Parameters

Configuring DTR Clients

Working with the SAP NetWeaver Development Infrastructure

Concepts of the NetWeaver Development Infrastructure

Component Model

Component Model – Concepts

Development Components (DCs)

Development Components – Concepts

Component Names

Nesting Development Components

Dependencies Between Development Components

Dependencies Between DC Types

Public Parts

Public Part Entities – Development Objects in Public Parts

Public Part Entity Reference

Purposes of Public Parts

Use Dependencies

Types of Development Components

Composite Application Services DC

Dictionary DC

Enterprise Portal DCs

External Library DC

J2EE DCs

J2EE Server Component – J2EE Library

Java DC

Web Dynpro DC

Web Services – Standalone and Deployable Proxy

Component Build

Access Control Between Components

Components in the Repository

Folder Structure of a Component

Component Definition

Software Components

Software Components – Concepts

Versioning of Software Components

Dependencies Between Software Components

Tips for Naming Components

Tips for Structuring Software with the Component Model

Central Source File Management

Definitions

Architecture of the DTR

Version Management for Source Files

Managing Files in Workspaces

Version and Change Management

Version Control

Adding Resources to the Repository

Activities – Creating and Changing Resources

Uncheck-Out of a Version

Deleting Versioned Resources

Resources in Workspaces

Concurrency Control

Modification of a Resource by Multiple Users and Conflicts

Modification of a Resource by Multiple Users

Resolving a Check-In Conflict

Distributed Development

Integrating Changes

Propagating Changes Between Repositories

Automatically Detecting Integration Conflicts

Resolving Integration Conflicts

Propagating a Conflict Resolution

Central Build Management

Component Build Service Architecture

Concepts of the Component Build Service

CBS Buildspace

Activation in the CBS

Rebuild of Dependent Development Components

Activation in Case of Errors

Synchronizing Build Tasks

Central Landscape and Transport Management

Software Components and Software Change Management

The Term ‘System’ in the CMS

Track Templates

Development Tracks

Working with Development Tracks

XI Tracks

Go & Create with the NWDI

Tutorial 2: “Development with a Track“

Tutorial 2: Development with a Track

Tutorial 2: Preparation

Creating Users and Assigning Groups

Creating a Software Component in the SLD

Creating a Domain and Track in the CMS

Checking In and Importing Required SCs

Tutorial 2: Step 0 – Importing the Development Configuration

Tutorial 2: Step 1 – Create, Locally Build, Check In a Java DC

Tutorial 2: Step 2 – Creating a J2EE Java Library DC

Tutorial 2: Step 3 – Create a J2EE Application

Tutorial 2: Step 4 – Testing and Checking In a DC

Tutorial 2: Step 5 – Activation in the CBS

Tutorial 2: Step 6 – Release Changes for Consolidation

Tutorial 2: Step 7 – Consolidate Changes

Tutorial 2: Step 8 – Create SCA (Assembly)

Tutorial 2: Step 9 – Import SCA into the Test System

Tutorial 2: Step 10 – Approve Transport

Tutorial 2: Step 11 – Import into Production System

Developing Business Applications

Scenario ”Java Projects with Central Source File Storage”

Development “Java Projects with Central Source File Storage“

Settings of the ”Ignored Resources“

Software Change Management Guide

Software Change Management Process

Creating the Workspaces

Creating Java Projects with Central Source File Storage

Building and Deploying on the Central Test System

Integrating Changes into the Consolidation Workspace

Consolidating Projects

Freezing Development States

Deployment in Other Systems

Maintenance and Support Packages

Splitting New Releases

Scenario “Developing Components with the NWDI“

Tips for Structuring Software with the Component Model

Structuring Software Components

Structuring Development Components

Development Steps in Component Development with the NWDI

Settings of the ”Ignored Resources“

Working with Development Configurations

Development Configurations Browser

Working with the Development Configurations Browser

Importing Development Configurations

Removing Development Configurations

Working With Components

Synchronizing a DC in a Local File System

Creating Development Components (DCs)

Creating Inner Development Components

DCs – Access Control List, Contained Folders, and Public Parts

Editing Development Components

Editing the Source Files of the Component

Editing DC Meta Data

Changing the Access Control List

Changing Child DCs

Changing Contained Folders

Changing Contained Package Names

Changing Used DCs

Changing Public Parts

Changing Public Part Entities

Changing Entity References

Migrating Projects to the NWDI

Migrating Java Projects to the NWDI

Migrating Local Web Dynpro Projects to the NWDI

Working With the DTR

Clients for the DTR Server

The DTR Client Perspective

Icons in the DTR Client

Activity Views

Functions in the Open Activities View

Functions in the Closed Activities View

Using the Repository Browser View

Configuring the DTR Perspective

Selecting the DTR Perspective

Selecting the Desired Views

Basic Operations in the DTR

Creating Activities

Editing Name and Description of an Activity

Unchecking Out an Activity

Checking In, Uploading, and Downloading Activities

Setting Options for the Workspace

Adding Resources to the Repository

Editing a File

Reverting Changes

Displaying the Version Graph of the Resource

“Sync” – Copying Versions to the Local File System

Deleting Resources From the Repository

Deleting Resources From the Client Workspace

Copying Files to the Local File System

Advanced Operations in the DTR

Creating Workspace Folders and Workspaces

Setting Preferences

Concurrent Development

Check-In Conflicts

Resolving Check-In Conflicts

Administration of the Distributed Development

Integrating Activities

Integration Conflict

Resolving Integration Conflicts

Working with the Component Build Service

Activating Activities and Build

Activating Activities in the CBS

Working with the Change Management Service

Transport View

Opening the Transport View

Releasing Activities

Administration of the SAP NetWeaver Development Infrastructure

Launching the NWDI Web User Interface

URL Parameters for CMS Web UI

Setting Up the Development Landscape: Landscape Configurator

Configuring a Domain

Naming Conventions

Creating a Development Track

Package Types

Loading the Software Component Configuration

Configuring Runtime Systems

Where-Used Check for Runtime Systems

Editing CBS Build Compartment XML

Build Options

Creating an XI Track

Editing a Track

Copying a Track (Save As ...)

Deleting a Track

Track Connections

Creating a Track Connection

Editing Track Connection Options

Updating the CMS

Track Details

Consistency Checks for Tracks

Resolving Inconsistencies

Transports with the NWDI: Transport Studio

General Functions in CMS Tables

Checking In Software Component Archives

Configuring Check-In Options

Imports

Restoring the System State

Unlocking Transports

Changing the Status of the Import Lock

Creating a Software Component Archive (Assembly)

Quality Assurance (Approval)

Forwarding Software Component Archives

System State

Transport and Build Monitoring

Details and Logs

History

CBS Web UI: Buildspaces View

Using the CBS Buildspace Details View

Managing Buildspaces in the CBS

Editing Buildspace Settings

Deleting Buildspaces

CBS Web UI: Activities View

Searching in the Activities View

CBS Web UI: Requests View

Searching in the Requests View

CBS Web UI: Compartments View

CBS Web UI: Development Components View

CBS Web UI: CBS Development Components DC Details

Triggering a DC Build

Downloading DC Archives

Icons in the CBS Web UI

Administration of the Design Time Repository Server

DTR Server Configuration

DTR Database

J2EE Engine

DTR – Configuration Areas

Logging

Administration of Server Contents

DTR Command Line Client

Starting and Stopping the Command Line Client

Local, Remote and Browse Paths

Help Tool

Command Reference

Frequent Tasks

Creating Workspace Folders and Workspaces

Finding and Listing Activities

Integrate activities

Administering Propagation Lists

Checking In Activities of Other Users

DTR Administrator Plug-In

Using the DTR Administrator Plug-In

Browser-Based Configuration and Query Tools in the DTR

Troubleshooting

Troubleshooting in the CBS

Monitoring the SAP NetWeaver Development Infrastructure

Monitoring the NWDI with JARM

Monitoring DTR and CBS with JMX

Monitoring the NWDI with GRMG

Reference

Tutorial 1: Team-Oriented Development

Tutorial 1: Team-Oriented Development

Tutorial 1: Preparation

Tutorial 1: Step 1 – Developer 1 Creates Projects

Tutorial 1: Step 2 – Developer 2 Enhances the Projects

Tutorial 1: Step 3 – Building, Deploying, and Running Projects

Tutorial 2: “Development with a Track“

Tutorial 2: Development with a Track

Tutorial 2: Preparation

Creating Users and Assigning Groups

Creating a Software Component in the SLD

Creating a Domain and Track in the CMS

Checking In and Importing Required SCs

Tutorial 2: Step 0 – Importing the Development Configuration

Tutorial 2: Step 1 – Create, Locally Build, Check In a Java DC

Tutorial 2: Step 2 – Creating a J2EE Java Library DC

Tutorial 2: Step 3 – Create a J2EE Application

Tutorial 2: Step 4 – Testing and Checking In a DC

Tutorial 2: Step 5 – Activation in the CBS

Tutorial 2: Step 6 – Release Changes for Consolidation

Tutorial 2: Step 7 – Consolidate Changes

Tutorial 2: Step 8 – Create SCA (Assembly)

Tutorial 2: Step 9 – Import SCA into the Test System

Tutorial 2: Step 10 – Approve Transport

Tutorial 2: Step 11 – Import into Production System

Tutorial 3: Layered Development

Tutorial 3: Preparation

Creating Users and Assigning Groups

Creating Software Components in the SLD

Creating a Domain and First Track in the CMS

Creating a Second Track

Connecting Tracks

“Layered Development”

Tutorial 3: Step 0 – Importing the Development Configuration

Tutorial 3: Step 1 – Create and Locally Build a Java DC

Tutorial 3: Step 2 – Create and Deploy a J2EE Java Library

Tutorial 3: Step 3 – Activation in the CBS

Tutorial 3: Step 4 – Release Changes for Consolidation

Tutorial 3: Step 5 – Consolidate Changes

Tutorial 3: Step 6 – Create SCA (Assembly)

Tutorial 3: Step 7 – Import SCA into the Test System

Tutorial 3: Step 8 – Approve Transport

Tutorial 3: Step 9 – Import into Production System

Tutorial 3: Step 10 – Import into the Follow-On Track

Tutorial 3: Step 11 – Create a J2EE Application

Tutorial 3: Step 12 – Test, Check In and Activate the DC

Tutorial 3: Step 13 – Release and Transport

Reference Guide of the NWDI

DTR Command Line Client

Starting and Stopping the Command Line Client

Local, Remote and Browse Paths

Help Tool

Command Reference

ACTIVITIES / ACTS

ACTIVITY / ACT

ADD

CD

CHECKIN

CLIENTS

CLOSEWORKSPACE / CLOSEWS

DELETE

DELETEWORKSPACE

DIFF

DIR

DOWNLOAD

EDIT

EXIT

EXPORT / EXP

GET

HELP

HISTORY

IMPORT / IMP

INTEGRATE

LDIR

MKACTIVITY / MKACT

MKDIR

MKLDIR

MKPROPAGATIONLIST / MKPL

MKWORKSPACE / MKWS

MOUNTPOINTS / MPS

MOVE

PREDECESSORS / PRED

PROPERTY / PROP

RDIR

REFRESH

REMOVE

REOPENWORKSPACE / REOPENWS

RESOLVE

SCRIPT

SERVERGARBAGECOLLECT

SETPASSWORD / SETP

WORKSPACES

UPLOAD

UNCHECKOUT / UNCO

STATUS / STAT

Frequent Tasks

Creating Workspace Folders and Workspaces

Finding and Listing Activities

Integrate activities

Administering Propagation Lists

Checking In Activities of Other Users

CBS Command Line Tool

Installing the CBS Command Line Tool

Running CBS Tool on Windows Platforms

Running CBS Tool on Linux/Unix Platforms

Dialog Mode for the CBS Tool

First Steps in the CBS Tool

Establishing a CBS Connection

User Messages and Technical Messages

Batch Mode in the CBS Tool

Commands for the CBS Command Line Tool

Alphabetical List of the Commands in the CBS Command Line Tool

Ensuring Quality

Testing Java Applications

JLin

Creating and Editing Variants

Executing Tests

Results

Testing Web Dynpro Applications in the Developer Studio

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

Logging and Tracing

Logging Quick Guide

How to Write Useful Log and Trace Messages

Logging

Addressees of Log Messages

How to Use Categories

Typical Types of Log Messages

Content of Log Messages

Severities Usable in Log Messages

Tracing

Addressees of Trace Messages

How to Use Locations

Typical Types of Trace Messages

Content of Trace Messages

Severities Usable for Trace Messages

General Design Issues

Example

Log Configuration

Adding, Editing, and Removing Log Formatters

Adding, Editing, and Removing Log Destinations

Adding, Editing, and Removing Log Controllers

Adding Filters to a Controller

Adding Associated Destinations to a Controller

Managing the log-configuration.xml Source

Log Severities

Remote Debugging in the SAP NetWeaver Developer Studio

Introduction

Debugging in a Single Server Configuration

Debugging in a Cluster Configuration

Preparing the Debugging Process

Activating Remote Debugging

Setting Breakpoints

Creating Launch Configurations for Debugging

Starting Debugging

Stopping Debugging

Best Practice

Debugging a Web Dynpro Application

Activating Debugging

Starting a Debug Session

Debugging ABAP Code from Within the Developer Studio

Debugging J2EE Applications

Activating Debugging

Preparations for Debugging a JSP

Debugging a JSP

Preparations for Debugging a Servlet

Debugging a Servlet

Reference

API Documentation

Tutorials

Web Dynpro

Basic Tutorials

Creating Your First Web Dynpro Application

Creating a Web Dynpro Project

Creating a Web Dynpro Component

Creating further Views

Specifying the Navigation Schema

Creating Actions and Implementing Navigation

Designing a View Layout

Defining Data Binding for UI Elements

Creating a Web Dynpro Application

Building, Deploying, and Running Your Application

Creating a Simple Web Dynpro Application

Creating a Web Dynpro Project

Creating a Web Dynpro Component

Creating and Designing a View

Defining a Web Dynpro Window

Defining a Web Dynpro Application

Deploying a Web Dynpro Project

Calling a Web Dynpro Application

Displaying the Current Date Using Data Binding

Structure of a Web Dynpro Application

Creating an Extended Web Dynpro Application

Quiz Application

Creating the First Parts of the Application

View Modeling and User Interface Layout

Determining the Content and Interaction of Views

Defining a View Composition

Implementing the View Composition

Designing a View Layout

Using the ActionButton Template

Creating Navigation Transitions

Controller Contexts and Data Binding

Defining Controller Contexts

Defining Data Binding

Context Programming

Adding QuizData Node Elements in Context Nodes

Initializing Top Level Value Attributes

Programming Context State Changes

Portal Integration of the Web Dynpro Application

A Simple Input Form

Application Example for Displaying Messages

Specifying the Project Structure

Declarative Development of a View

Defining Simple Type Data Types in the Java Dictionary

Developing the Form View

Developing the EMailEditor View

Defining the navigation structure

Defining Messages

Implementing the View Controller

Implementing the Controller of the Form View

Implementing the Controller of the EMailEditor View

Advanced Tutorials

Model Tutorials

Creating a Web Dynpro Application Accessing ABAP Functions

Importing a Project Template

Developing the Example Application – Steps

Creating a Model

Creating a Custom Controller Context and Binding it to the Model

Mapping Custom Context Elements to View Context Elements

Creating Actions and Declaring Methods

Editing the UI Elements

Adding the Implementation of the Backend Connection

Building, Deploying, Configuring, and Running Your Application

Creating an Email Client Using Web Dynpro and Web Services

Creating a Project Structure

Creating a Web Service Model

Creating the Binding: Component Controller Context and Model

Mapping View Context Elements to Component Context Elements

Creating the SendEmail Action

Designing a View Layout

Adding the Implementation for the Web Service Connection

Calling the Execute Method

Building, Deploying, and Running the Project

Using the Car Rental Web Service with Web Dynpro

Importing a Project Template

Creating a Model

Creating a Component Context and Binding It to the Model

Mapping a View Context onto the Component Controller

Defining Data Binding for UI Elements

Implementing the Event Handler of the View

Building, Deploying, and Running Your Application

Context Tutorials

Application of Context Programming and Data Binding

The Master/Detail Viewer Application

Specifying the Project Structure

Context Design in the Master/Detail Viewer

Declaring the Controller Context of a View

Designing a View Layout

Binding Tables to the Controller Context of a View

Implementing the Controller Context of a View

Implementing a Demo BOL

Initializing the Controller Context of a View

Adding a Supply Function

User Interface Tutorials

Tutorial: Developing with Tables in Web Dynpro

Importing the Project Template

Creating the Component Controller Context

Mapping the View Context onto the Component Controller Context

Enhancing the View Context

Creating the Table

Binding the Table to the Context

Creating and Binding the Detailed Form

Deleting Single or Several Rows

Sorting

Calculating the Total per Article

Calculating the Total

Setting and Changing the Currency

Building, Deploying, and Running the Table Tutorial

Constructing a Recursive and Loadable Web Dynpro Tree

Importing a Project Template

Recursive Context Nodes

Further Procedure for Creating the Web Dynpro Tree

Creating the Context for the TreeView

Creating Actions for the Tree

Creating UI Elements

Creating a Resource Bundle for the File Structure

Initialising the Context

Mapping the Event Parameters

Event Handling: Expanding a Node

Event Handling: Selecting an Entry

Building, Deploying, and Running the Project

Dialog Boxes in Web Dynpro Applications

Importing a Project Template

Creating an External Window

Creating a Dialog Box

Creating a Web Dynpro Window for the Address Book

Interaction of the EmailWindow and the AddressbookWindow

Creating a Confirmation Dialog Box

Executing the Complete Application

Value Help in Web Dynpro Applications

Example Application of a Value Selector

Simple Value Selector

Specifying the Project Structure

Inserting a Simple Value Selector

Including an Extended Value Selector

Modeling View Compositions in Web Dynpro

Importing a Project Template

Developing the Example Application for a View Composition

Adding the ViewContainerUIElement

Embedding a View Set in a ViewContainerUIElement

Using ViewContainerUIElements

Using a Web Dynpro Component

Embedding an Inner View Set

Embedding Component Interface Views in a View Set

Controlling the Lifecycle of a Component Instance

Component Tutorials

Using Server-Side Eventing in Web Dynpro Components

Eventing Example Application

Creating a Project Structure

Implementing the View Composition

Developing the Internal Web Dynpro Component

Declaring Event and Method in the Interface Controller

Setting Declarations in the Form View Controller

Designing the Layout of the Form View

Implementing Form View Controller and Interface Controller

Developing the Web Dynpro Component

Setting Declarations in the ControlPanel View Controller

Designing the Layout of the ControlPanel View

Implementing the Controller of the ControlPanel View

Using External Context Mapping

Special Tutorials

Portal Tutorials

Running a Web Dynpro Application in SAP Enterprise Portal

Define a System

Creating a Web Dynpro-Based iView

Creating a Web Dynpro iView Template

Programming Portal Eventing

Subscribing to a Portal Event

Code Example for Programming Portal Eventing

Navigation Between Web Dynpro Applications in the Portal

Creating a Sample Web Dynpro Project for Page Navigation

Integrating Applications in the Portal

Defining the View of the Start Application

Defining the View of the Target Application

Building, Deploying, and Running the Project

Testing and Executing Applications in the Portal

Object-Based Navigation Between Web Dynpro Applications (OBN)

Integrating Web Dynpro Applications into the Portal

Importing a Business Object

Creating a Business Object Operation

Assigning Business Object Operations to the iView

Defining the User Interface Element DropDownBoxByIndex

Providing Services

Defining Authentication

Creating a Reference to the IUserObjectBasedNavigation Service

Implementing the Source Code for the View

Defining Parameter Transfer

Filling the Context Attributes with Data

Result of the Web Dynpro OBN Tutorial

Developing International Web Dynpro Applications

Importing a Project Template

Creating Texts for the Original Language

Creating the Simple Types

Create the context and action

Completing the Layout of the Application

Creating a Warning Message and Implementing onActionRent()

Create dynamic texts and complete the application

Translating Text Resources into Other Languages

Define language-specific application properties

Executing and Testing the Application

User Interface Tutorials

Using Business Graphics

Carrying Out the Initial Steps

Inserting a Business Graphic in the View

Editing the Properties for the UI Element

Editing the Context for the View

Changing Type Property of Data Series

Binding the Data

Supplying the Context with Data

Building, Deploying and Running the Project

Using Geo Services With Web Dynpro

Overview on Geo Services and IGS

Importing a Project Template

Create the Example Application “Using Geo Services“

Extend the Context of the GeoServiceView

Extend the Layout of the GeoServiceView

Implement the Action Handler onActionShowRoute

Zooming In

Execute the Application Tutorial_GeoServices

Debugging Tutorials

Debugging a Web Dynpro Application

Activating Debugging

Starting a Debug Session

Debugging ABAP Code from Within the Developer Studio

Dynamic UI Generation in Web Dynpro

Importing a Project Template

Overview of Dynamic Programming in the Web Dynpro

Creating Dynamic User Interface Elements

Dynamically Building the Appropriate Context

Dynamically Creating the Form

Dynamically Creating Pushbuttons with Appropriate Actions

Action Handling

Executing the Application TutWD_Dynamic_Init

Protecting Access to the Web Dynpro Application Using UME Permis

Concepts Necessary for Using UME Permissions with this Tutorial

Authentication Between the Components Using Logon Tickets

Permissions, Actions, and UME Roles

Permission Class for Your Application

actions.xml File

UME Archive File

Importing the Project Templates for the Web Dynpro Tutorial

Integrating UME Permissions in the Web Dynpro Application - Step

Including the UME Libraries and Web Service References

Specifying Authentication for the Application

Specifying Authentication for Access to the Web Dynpro Client

Specifying Authentication for Access to the Web Service

Creating the HTTP Destination

Using the HTTP Destination Within the Web Dynpro

Protecting Access to the EJB Methods Using UME Permissions

Creating the Permission Class for the EJB Methods

Obtaining the User ID from the Context

Checking the Permission in the EJB Methods

Adjusting the Message Handling

Rebuilding the Projects and Redeploying the Application

Defining Actions in the actions.xml File

Build and Deploy the Archive File

Creating the Users

Creating UME Roles

Assigning Users to the Roles

Testing the Access Protection

Checking Permissions in the Web Dynpro Frontend Client

Including the UME JAR File in the Web Dynpro Project

Creating the Permission Class for the Web Dynpro

Checking the Permission in the Web Dynpro Client

Rebuilding and Redeploying the Project

Defining Actions for the Web Dynpro Project

Modifying the UME Roles and User Assignments

Testing the Access Protection

J2EE

Creating Your First J2EE Application

Creating an EJB Module Project

Developing the Calculator Session Bean

Creating the Enterprise Bean Archive

Creating a Web Module Project

Developing the JavaBean CalcProxy

Developing the Calculator.jsp

Building the Web Archive

Assembling the Calculator Application

Deploying and Running the Calculator Application

Creating a J2EE-Based Car Rental Application

Defining a Data Model

Creating a Dictionary Project

Creating a Table

Adding Table Columns

Creating an SDA

Deploying an SDA

Implementing Data Access

Creating an EJB Module Project

Creating the QuickBookingBean Entity Bean

Adding the Implementation of the ejbCreate Method

Implementing the Business Logic

Creating and Implementing Auxiliary Classes

Creating a Java Project as a Source Container

The Constants Class

The QuickBookingModel JavaBean

The Exception Class QuickCarRentalException

Exporting the JAR File

Creating the Session Bean QuickOrderProcessorBean

Implementing the Session Bean Class

Throwing the Exception QuickCarRentalException

Implementing the saveBooking() Method

Implementing the cancelBooking() Method

Implementing the viewActiveBookings() Method

Creating a JAR

Editing Deployment Descriptors

Adding Descriptions to ejb-jar.xml

Adding Descriptions to persistent.xml

Adding Descriptions to ejb-j2ee-engine.xml

Creating a Jar File

Implementing a Web Application

Creating a Web Module Project

Creating the JSP quickCarRentalView

Adding Source Code

Creating the QuickReservationServlet Servlet

Adding Source Code to the Servlet

Creating a Web Archive

Editing Deployment Descriptors

Adding Descriptions to web.xml

Creating a War File

Creating and Deploying the Complete J2EE Application

Creating an Enterprise Application Project

Editing Deployment Descriptors

Adding Descriptions to application.xml

Creating a DataSource Alias

Creating an Ear File

Deploying an EAR

Executing the Car Rental Application

Making the Car Rental Application Available as a Web Service

Creating a Web Service

Deploying the Web Service QuickCarRentalService

JavaMail Tutorial

Creating EJB Project

Creating a Java Class

Setting Classpath and Compiling Sources

Creating References in the ejb-jar.xml File

Creating a Web Project

Creating a New Java Package

Servlet Files

Creating the Servlet Files

HTML Files

Creating the HTML Files

Creating a Reference in the web.xml File

Creating an Assembly Project

Generating Files for Deployment

Deploying the EAR

Debugging J2EE Applications

Activating Debugging

Preparations for Debugging a JSP

Debugging a JSP

Preparations for Debugging a Servlet

Debugging a Servlet

Persistence

Getting Started with Relational Persistence

Creating the Database Tables

Creating the Web Project

Developing the EmployeeData Class

Developing the Data Access Interface

Creating the SQLJ Connection Context

Creating an SQLJ ResultSet Iterator

Implementing the Data Access Interface with SQLJ

Implementing the Data Access Interface with JDBC

Developing the Web Front End

Assembling the Application

Deploying and Running the Application

Getting Started with JDO

Creating the Database Tables

Creating the Web Project

Defining the Persistence Capable Classes

Defining the Object Identity Classes

Defining the JDO Metadata

Defining the O/R Mapping

Running the JDO Enhancer and Checker Tools

Implementing the Business Logic

Developing the Web Front End

Assembling the Application

Deploying and Running the Application

Security

Protecting Access to a J2EE-Based Application Using J2EE Securit

Importing the Project for the J2EE-Based Car Rental Tutorial

Using J2EE Security Roles in the Application - Steps

Protecting Access to the Application in the JSP

Specifying Authentication in the JSP

Specifying the Policy Domain to Use for Authentication

Creating a J2EE Security Role for Accessing the Application

Creating a Security Constraint

Protecting Access to the EJB Methods Using J2EE Security Roles

Creating the J2EE Security Roles to Use for the EJB Methods

Selecting the EJB Methods for Each J2EE Security Role

Catching the Access Control Error

Rebuilding and Deploying the Application

Creating the Users

Assigning Users to the J2EE Security Roles

Testing the Access Protection

Protecting Access to a J2EE-Based Application Using UME Permissi

Concepts Necessary for Using UME Permissions with this Tutorial

Permissions, Actions, and UME Roles

Permission Class for Your Application

actions.xml File

UME Archive File

Importing the Project for the J2EE-Based Car Rental Tutorial

Using UME Permissions in the Application – Steps

Including the UME Libraries

Protecting Access to the JSP Using Authentication and UME Permis

Requiring Authentication

Creating the Permission Class for the JSP

Checking the Permission in the Application

Protecting Access to the EJB Methods Using UME Permissions

Creating the Permission Class for the EJB Methods

Obtaining the User ID from the Context

Checking the Permission in the EJB Methods

Rebuilding the Projects and Redeploying the Application

Defining Actions in the actions.xml File

Build and Deploy the Archive File

Creating the Users

Creating UME Roles

Assigning Users to the Roles

Testing the Access Protection

Protecting Access to the Web Dynpro Application Using UME Permis

Concepts Necessary for Using UME Permissions with this Tutorial

Authentication Between the Components Using Logon Tickets

Permissions, Actions, and UME Roles

Permission Class for Your Application

actions.xml File

UME Archive File

Importing the Project Templates for the Web Dynpro Tutorial

Integrating UME Permissions in the Web Dynpro Application - Step

Including the UME Libraries and Web Service References

Specifying Authentication for the Application

Specifying Authentication for Access to the Web Dynpro Client

Specifying Authentication for Access to the Web Service

Creating the HTTP Destination

Using the HTTP Destination Within the Web Dynpro

Protecting Access to the EJB Methods Using UME Permissions

Creating the Permission Class for the EJB Methods

Obtaining the User ID from the Context

Checking the Permission in the EJB Methods

Adjusting the Message Handling

Rebuilding the Projects and Redeploying the Application

Defining Actions in the actions.xml File

Build and Deploy the Archive File

Creating the Users

Creating UME Roles

Assigning Users to the Roles

Testing the Access Protection

Checking Permissions in the Web Dynpro Frontend Client

Including the UME JAR File in the Web Dynpro Project

Creating the Permission Class for the Web Dynpro

Checking the Permission in the Web Dynpro Client

Rebuilding and Redeploying the Project

Defining Actions for the Web Dynpro Project

Modifying the UME Roles and User Assignments

Testing the Access Protection

Appendix

Deployment Descriptors

appclient-j2ee-engine.dtd

application-j2ee-engine.dtd

connector-j2ee-engine.dtd

data-source-aliases.dtd

data-sources.dtd

db-init.dtd

deploy-manager-config.dtd

deploy-manager-config.xml

ear-generator.dtd

ear-generator.xml

ejb-j2ee-engine.dtd

j2ee-components-generator.dtd

j2ee-components-generator.xml

jms-destinations.dtd

jms-factories.dtd

library.provider.dtd

log-configuration.dtd

monitor-configuration.dtd

persistent.dtd

server_component_management.dtd

server_component_management.xml

web-j2ee-engine.dtd

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

SQLJ Runtime API

sqlj.runtime.ConnectionContext

sqlj.runtime.ForUpdate

sqlj.runtime.NamedIterator

sqlj.runtime.PositionedIterator

sqlj.runtime.ResultSetIterator

sqlj.runtime.Scrollable

sqlj.runtime.AsciiStream

sqlj.runtime.BinaryStream

sqlj.runtime.CharacterStream

sqlj.runtime.ExecutionContext

com.sap.sql.BatchExecutionContext

com.sap.sql.CardinalityViolationException

com.sap.sql.NoDataException

sqlj.runtime.SQLNullException

Open SQL Reference

Open SQL Database Dependencies

Open SQL Grammar

Lexical Issues

Keywords

Identifiers

Regular Identifiers

Delimited Identifiers

Literals

Statements

SELECT Statement

Query Specification

FROM Clause

Joined Table

Table Reference

WHERE Clause

GROUP BY Clause

HAVING Clause

Select List

UNION

ORDER BY Clause

INSERT Statement

UPDATE Statement

DELETE Statement

SELECT FOR UPDATE Statement

SELECT INTO Statement

Value expressions

Column References

Set Functions

Arithmetic Expressions

Dynamic Parameter Specification

Search Condition

Comparison predicate

Scalar Subqueries

Quantified comparison predicate

Between predicate

In predicate

Like predicate

Null predicate

Exists predicate

Boolean Expressions

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

JDO Reference

JDO State Checks

JDO State Transitions

JDOQL Operators

JDO Mapping Metadata DTD

UME Reference

Logical Attributes

Standard UME Actions

Preconfigured Data Source Combinations

UME Properties

SAP* Superuser

Default Groups

Data Source

SAP ABAP-Based System as Data Source

LDAP Directory Data Source

LDAP Directory: Connection Pooling

Logon

SAP Logon Ticket

Logoff

Replication

User Mapping

Administration

Security Policy

E-Mail Notification

Backwards Compatibility with SAP Enterprise Portal 5.0

Caching

Companies

Users

SAP XML Toolkit for Java

XML Schema Validation

Obtaining SAX and DOM Parsers

Java API for XML Parsing (JAXP)

Document Object Model (DOM)

Building DOM Trees Through Parsing

Traversing

Building DOM Trees from a Document

Processing XML Using SAX

ContentHandler and DefaultHandler Implementation

XSL Transformations

Output Properties

Transforming Without Stylesheet - Converting

Transforming Without Stylesheet

Advanced Techniques

Java Integration

Multiple Output Documents

SAP XML Toolkit for Java FAQ