SAP Library - Development Manual

Development Manual

The SAP NetWeaver Developer Studio

Overview 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

SAP Java Test Tools

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

Remote Debugging in the SAP NetWeaver Developer Studio

Getting Started with Remote Debugging

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

Restoring the Full Productive State of the J2EE Engine

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

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

Creating Web Objects 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

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

SAP Java Test Tools

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

Getting Started

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

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

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

Debugging a Web Dynpro Application

Activating Debugging

Starting a Debug Session

Starting and Stopping the SAP System

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

Developing Web Applications

Web Dynpro

Portal Integration of Web Dynpro Applications

Running a Web Dynpro Application on the Portal

Define a System

Create a Web Dynpro iView Template

Create a Web Dynpro iView

Define Role Based iViews

Enterprise Portal Client Framework (EPCF)

Subscribe to a Client Event

Unsubscribe a Client Event

Raise a Client Event

Enterprise Portal Navigation

Absolute Page Navigation

Relative Page Navigation

Enterprise Portal Object Based Navigation (OBN)

Triggering Object Based Navigation

Using the IUserObjectBasedNavigation Service

Accessing an Enterprise Portal Service

Using the Work Protect Mode

Defining the Theme for Web Dynpro Applications

Web Dynpro Clients

Mobile Web Dynpro

Special Features of BlackBerry Wireless Handhelds

Special Features of Pocket PCs

Special Features of the Nokia Series 80 Devices

Procedures for Developing a WD Application

Setting Up a 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

Developing Locally

Creating a New Web Dynpro Project

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

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

JavaBean Model in a Development Component Project

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

View Templates

Using the Form Template

Using the Table Template

Using the ActionButton Template

Working with User Interface Elements

UI Element Reference Guide

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 for Using 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

Using OfficeControl

Code Examples of Data Binding

The User Interface Element Container

Creating a Plug

Implementing Methods for Outbound Plug Calls

Creating a Link

Implementing the Data Flow

Event Handling

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

Logging

Client Tracing

Metadata Comparison for Web Dynpro Projects

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

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

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 for Using 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

Using OfficeControl

Code Examples of Data Binding

Event Handling

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

UI Element Reference Guide

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 Basic Application Parts

View Modeling and User Interface Layout

Designing a View Model

Defining a View Composition

Implementing the View Composition

Designing a View Layout

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

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

Integration of a Tree Structure in a Web Dynpro Table

Importing a Project Template

Further Procedure for Developing the Web Dynpro Application

Recursive Context Nodes

Creating a Context in the Controller of the View TreeTableView

Creating Actions and Methods for the TreeTableView

Adding a Table with TreeByNestingTableColumn

Implementing the Tree Structure

Executing the Application

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 in Web Dynpro View Compositions

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

Uploading and Downloading Files in Web Dynpro

Importing the Project Template

Using the UI Elements FileUpload and FileDownload

File Upload – Defining the Context and View Layout

Implementing the FileUploadView Controller

Running the Application - File Upload

File Download – Defining the Context and View Layout

Implementing the FileDownloadView Controller

Running the Application - File Download

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

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 Programming 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 Web Applications

J2EE Application Concepts

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

Session Support for Concurrent Requests

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

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

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

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