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

Creating Stateful Session Beans

Creating Stateless Session Beans

Creating Entity Beans

Creating Message-Driven Beans

Editing Enterprise Beans

Adding and Removing Methods

Adding and Removing Fields

Adding and Removing Relations

Propagating Methods to the Remote and Local Interfaces

Building EJB JARs

Creating Web Module Projects

Creating Enterprise Application Projects

Adding Modules to Enterprise Application Projects

Building EARs

Specifying Additional Libraries to be Packed into EAR Files

Deploying EARs

Creating Data Source Aliases

Creating Web Module DC Projects

Building Web Module DC Projects

Creating EJB Module DC Projects

Building EJB Module DC Projects

Creating Enterprise Application DC Projects

Building Enterprise Application DC Projects

Creating Packages

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

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

Debugging JSPs and Servlets

Enabling Debugging on the Server

Setting Breakpoints in JSP Pages and Servlets

Creating Debug Launch Configurations

Starting and Stopping Debugging

Working with J2EE Libraries

Defining Libraries

Creating a New Library Project

Adding JARs and References

Creating a Library Archive

Deploying a Library Archive

Defining Library DCs

Creating a New Library DC

Declaring the Use of Other DCs

Executing the Component Build

Referencing Libraries in Applications

Importing J2EE Sources

Importing Developer Studio J2EE Projects

Migrating from Web AS 6.20

SAP Web AS 6.20 and the Developer Studio

Assembling Enterprise Beans from Existing Classes

Propagating Metadata from ejb-jar.xml to Sources

Diagram View

Editing EJB Module Projects in the Diagram View

Creating Packages 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 Module 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 Application 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

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

Using External Data Imported from an XMI Model

Conditions for an XMI Model Import

Referencing a Model

Java Dictionary

Dictionary Perspective

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

Web Service Navigator

Advanced Techniques

Creating a Web Service with Attachments

Maintaining SOAP Extensions

Accessing the Web Services Context from a WS-EJB

Customizing the SOAP Fault Element Inside the Web Service

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 Dynpro and Web Services

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 View Context Elements to Custom 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 Web Dynpro to Avail of the Car Rental Web Service

Importing a Project Template

Creating a Model

Creating a Component Context and Binding It to the Model

Mapping Component Context to View Context

Defining Data Binding for UI Elements

Adding Source Code for the Web Service Connection

Building, Deploying, and Running the Project

Using an Email Web Service in Web Dynpro

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

Building, Deploying, and Running Your Application

JavaMail Tutorial

Creating EJB Project

Creating a Java Class

Setting Classpath and Compiling Sources

Creating References in the ejb-jar.xml File

Creating Web Project

Creating a New Package

Servlet Files

Creating the Servlet Files

HTML Files

Creating the HTML Files

Creating a Reference in the web.xml File

Creating 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

Developing Web Applications

Web Dynpro

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

Introduction

Terminology

Project

Web Dynpro Application

Plugs and Navigation Links

Controllers

Event

Context

Data Binding and Mapping

Web Dynpro Model

Concept

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

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

Using External Data Imported from an XMI Model

Conditions for an XMI Model Import

Referencing a Model

Procedures

Creating the First Application Elements

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

Referencing a Model

Defining Dictionary Data Types and Structures

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

The User Interface Element Container

Creating a Plug

Implementing Methods for Outbound Plug Calls

Creating a Link

Implementing the Data Flow

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

Model Binding

Providing Data Using Value Nodes and Value Attributes

Using the Service Controller

Implementing Event Handlers

Programming User Messages

Creating a User Message

Deploying and Executing a Web Dynpro Application

Logging

Integrating a WD Application in the SAP Enterprise Portal

Using the Template for Portal Eventing

How-To Guide: Creating a Web Dynpro Application

The Development Process

Setting Up a Web Dynpro Project

Developing Locally

Creating a New Web Dynpro Project

Developing in the 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

Designing Web Dynpro Applications

Architecture Design

Modeling Development Components

Modeling Web Dynpro Projects

Detail Design

Modeling Web Dynpro Components

Modeling Web Dynpro Windows

Administration/Configuration of Web Dynpro Runtime Environment

Monitoring Web Dynpro Applications with Console Commands

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

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

Use of WorkProtect Mode

Context Description

Context Node Behavior at Design Time and Runtime

Supply Function

Singleton Node and Non-Singleton Node

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 Table

Code Example for Table Display

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

Code Example of the Use of an Interactive PDF form

Example of the Use of an Office Document

Code Examples of Data Binding

Dynamic Programming of UI Elements

Example for Using Messages

Debugging a Web Dynpro Application

Enabling Debugging on the Server

Setting Breakpoints in Web Dynpro Applications

Creating Debug Launch Configurations

Starting and Stopping Debugging

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

User Management Service

Internationalization Service

URL Generation Service

Services for the SAP System Landscape Directory and SAP Java Con

UI Element Reference Guide

Mobile Web Dynpro

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 Changes

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 View Context Elements to Custom 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 an Email Web Service in Web Dynpro

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

Building, Deploying, and Running Your Application

Using Web Dynpro to Avail of the Car Rental Web Service

Importing a Project Template

Creating a Model

Creating a Component Context and Binding It to the Model

Mapping Component Context to View Context

Defining Data Binding for UI Elements

Adding Source Code for the Web Service Connection

Building, Deploying, and Running the Project

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

Value Help in Web Dynpro Applications

Example Application of a Value Selector

Simple Value Selector

Specifying the Project Structure

Inserting a Simple Value Selector

Inserting an Extended Value Selector

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

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

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

Debugging a Web Dynpro Application

Activating Debugging

Starting a Debug Session

J2EE Web Applications

J2EE Application Concepts

Hints on Designing J2EE Web Applications

Developing J2EE Web Applications

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

SAP 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 SAP 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 SAP J2EE Engine

Single Sign-on for J2EE Web Applications

Propagation of Security Principals to Other Containers on the SA

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 SAP J2EE Engine Cookies

Limiting the Number of HTTP Sessions

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

Developing Business Logic

Developing Enterprise Beans

Introduction to Enterprise Beans

Enterprise Bean Structure

SAP J2EE Engine EJB Architecture

Developing an EJB Application

Creating EJB Module 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 the Enterprise Bean’s JNDI Name

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

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 Relationships Between Container-Managed Entity Beans

Defining Transaction Attributes

Specifying the Enterprise Bean’s JNDI Name

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 the Enterprise Bean’s JNDI Name

Specifying JNDI Names for the Beans References

Configuring Message-Driven 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

Building EJB JARs

Creating Enterprise Application Projects

Building EARs

Deploying EARs

Configuring Enterprise Beans After Deployment

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

Using the Default DataSource

Deploying a DataSource Alias with an Application

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

Creating and Editing SQLJ Sources

Database Connection Context

Execution Context

Host Variables and Host Expressions

Combining SQLJ and JDBC

Transactions in Open SQL/SQLJ

Using the SQLJ Checker

Debugging SQLJ Sources

Reading and Writing LOBs En Bloc

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

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 Distributed and Local Transactions

Sharing Connections

Database Connection Management

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

Web Service Navigator

Advanced Techniques

Creating a Web Service with Attachments

Maintaining SOAP Extensions

Accessing the Web Services Context from a WS-EJB

Customizing the SOAP Fault Element Inside the Web Service

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 Dynpro and Web Services

Web Services Security

Secure Transmission

WS Security

Authentication

Configuring Transport Authentication

Configuring Document Authentication

Authorization

UDDI

Initial Configuring

Creating Business Entities

Publishing a Web Service as a Business Service

Publishing a Web Service Definition as a tModel

UDDI Discovery for Creating Web Service Clients

Querying UDDI

Changing the Database of the UDDI Server

General Architecture

Server-Side General Architecture

Client-Side General Architecture

Web Service Clients

Web Service Client Core Concept

Service Interfaces

Service Endpoint Interface

Logical Ports

Deployable versus Standalone Proxies

Implementing a Web Service Client Application

Programming a Web Service Client Application

Working with SOAP Protocols

Using the SOAP Headers Protocol

Using the Session Protocol

Using the Security Protocol

Extending the Web Service Framework

Server Side

Implementation Container

Protocol

Protocol Interface

ProtocolContext Interface

Loading WSDL Definitions

Loading Schema Definitions and Generating Schema Helper Classes

Generating Interfaces

Generating Stubs and Analyzing Binding Extension Tags

Saving Logical Ports

Protocol

FeatureProvider Interface

PropertyContext Interface

AbstractProtocol Interface

HTTPTransport Interface

Protocol Implementation Details

Logging and Tracing

Appendix

Restrictions for WS Endpoints

Writing ABAP-Compliant Web Services

Rules for Proxy Generation

Command Line Proxy Generator

Proxy Generator Usage Through Java API

Schema to Java Generator and Serialization Framework

External Web Services Runtime Data Generator

Setting up an SLD Test Server

Java Messaging

JMS Service – Development

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

Publish-Subscribe Model

Creating Message Producer to a Topic

Creating Message Consumer to a Topic

Synchronously Receiving Messages Sent to a Topic

Asynchronously Receiving Messages Sent to a Topic

Managing Durable Subscriptions

Creating Message Selector

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 the Enterprise Bean’s JNDI Name

Specifying JNDI Names for the Beans References

Configuring Message-Driven Specific Properties

Specifying References to Objects Bound in the JNDI

Message-Driven Bean Example

JMS Messages

Unpacking the Received Messages

Message Acknowledgement

Security on JMS Service

Closing the JMS Connection

JMS Scenarios

Simple Point-to-Point Scenario

Point-to-Point Scenario with Client Confirmation

Simple Publish/Subscribe Scenario

Publish/Subscribe Scenario with Permanent Backup

Simple Transaction Message Processing

Message Processing: Confirmation in a Temporary Queue

Using Message Filters

Source Code of JMS Scenarios

Java Dictionary

Dictionary Perspective

Working with the SAP NetWeaver Java Development Infrastructure

Getting Started – Development Infrastructure

Tutorial for Scenario 1: Team-Oriented Development

Scenario 1: Preparation

Scenario 1: Step 1 – Developer 1 Creates Projects

Scenario 1: Step 2 – Developer 2 Enhances the Projects

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

Tutorial for Scenario 2: Development with Components

Scenario 2: Preparation

Scenario 2: Step 1 – Create and Locally Build a Java DC

Scenario 2: Step 2 – Create and Deploy a J2EE Java Library

Scenario 2: Step 3 – Create a J2EE Application

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

Scenario 2: Configure a Central Component Build

Tutorial for Scenario 2+: Development with a Track

Scenario 2+: Preparation

Creating Users and Roles

Creating a Software Component in the SLD

Creating a Domain and Track in the CMS

Checking In and Importing Required SCs

Scenario 2+: Step 1 – Creating and Locally Building a Java DC

Scenario 2+: Step 2 – Creating a J2EE Java Library

Scenario 2+: Step 3 – Creating a J2EE Application

Scenario 2+: Step 4 – Testing and Checking In a DC

Scenarios 2+ and 3: Step 5 – Activation in theCBS

Scenarios 2+ and 3: Step 6 – Releasing Changes for Consolidation

Scenarios 2+ and 3: Step 7 – Consolidating Changes Made by Devel

Scenarios 2+ and 3: Step 8 – Creating a Version of the Applicati

Scenarios 2+ and 3: Step 9 – Importing a New Version into the Sy

Scenarios 2+ and 3: Step 10 – Approving a Transport into the Pro

Scenarios 2+ and 3: Step 11 – Importing an Application into the

Tutorial for Scenario 3: Layered Development

Scenario 3: Preparation

Creating Users and Roles

Creating Software Components in the SLD

Creating a Domain and First Track in the CMS

Creating a Second Track

Connecting Tracks

Checking In and Importing Required SCs

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

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

Scenario 3: Step 3 – Create a J2EE Application

Scenario 3: Step 4 – Testing and Checking In a DC

Scenarios 2+ and 3: Step 5 – Activation in theCBS

Scenarios 2+ and 3: Step 6 – Releasing Changes for Consolidation

Scenarios 2+ and 3: Step 7 – Consolidating Changes Made by Devel

Scenarios 2+ and 3: Step 8 – Creating a Version of the Applicati

Scenarios 2+ and 3: Step 9 – Importing a New Version into the Sy

Scenarios 2+ and 3: Step 10 – Approving a Transport into the Pro

Scenarios 2+ and 3: Step 11 – Importing an Application into the

Scenario 3: Step 12 – Import into the Follow-On Track

Scenario 1: Team-Oriented Development

Development Process in Scenario 1

Settings of the ”Ignored Resources“

Software Change Management Guide

Software Change Management Process

Creating the Workspaces

Scenario 1 – Creating Projects

Scenario 2 – Creating Projects in Development Components

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 2: Development with Components

Development Process in Scenario 2

Working with Development Configurations

Creating Development Configurations in the Configuration Wizard

Importing Development Configurations

Removing Development Configurations

Development Configurations Browser

Working with the Development Configurations Browser

Example Development Configuration

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

Central Build Process in Scenario 2

Building Development Components Centrally

Loading a DC from the DTR – the “sync” Command

Building a Component – the “build“ Command

Building All Components – the “buildall“ Command

Optional Parameters – Security

Optional Command Line Parameters – Tracing

Example: Command Line Parameters

Scenario 2+: Development with a Track

Development Steps in the Scenarios 2+ and 3

Working with Development Configurations

Development Configurations Browser

Working with the Development Configurations Browser

Importing 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

Working with the Component Build Service

Activating Activities and Build

Activating Activities in the Component Build Service

Change Management Service: Transport View

Transport View

Opening the Transport View

Scenario 3: Layered Development

Development Steps in the Scenarios 2+ and 3

Working with Development Configurations

Development Configurations Browser

Working with the Development Configurations Browser

Importing 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

Working with the Component Build Service

Activating Activities and Build

Activating Activities in the Component Build Service

Change Management Service: Transport View

Transport View

Opening the Transport View

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

Integrating Security Functions

The Security Service Development API

Authentication for Web Applications Users on the SAP J2EE Engine

Overview of the Login Process in JAAS

Using Login Modules to Protect Web Applications

Example Login Module

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 SA

Integration of SAP J2EE Engine and UME Authentication

Remote Authentication

Security Sessions

Obtaining the Current Security Session

Using Security Roles and Security Role References

SAP J2EE Engine Security Roles

Architecture of Security Roles

Permissions, Actions, and UME Roles

Protection Domains

Security Methods to Use for Applications

Security Aspects of Web Dynpro for Java

Getting Key Storage Service

Performing Code-Based Security Checks

Key Storage Actions

The Secure Storage API

Interfaces and Classes for Using Secure Storage

Examples for Using Secure Storage Interfaces and Classes

The Digital Signatures and Document Encryption API

Interfaces and Classes for Using Digital Signatures and Encrypti

Examples for Using Digital Signatures

The Secure Connection Factory API for HTTPS Clients

Interfaces and Classes for Using the Secure Connection Factory

Examples for Using the Secure Connection Factory

The Destination Service API

Interfaces and Classes for Using the Destination Service API

Examples for Using the Destination Service API

Additional Programming Techniques

Administration

JMX Service Interface

Architecture

Writing MBeans

Connecting to an MBeanServer

Registering MBeans

Accessing MBeans

Query MBeans

Receiving Notifications

Compile and Run your Client

Administration Adapter Service

Monitoring

Monitoring Framework

Monitoring Tree

Interaction between the Monitoring Framework and the Monitored R

monitor-configuration.xml Structure

Using Templates to Install Monitors Dynamically

Example of Using Template Monitors

Instrumenting an Application to Provide Monitoring Data

Creating the monitor-configuration.xml

Registering Resource MBean(s)

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

Putting it All Together

Example of Application Instrumented with Monitoring

Designating the Variables You Want to Monitor

Developing the Resource MBean and the monitor-configuration.xml

Text Monitor - "Bank Name"

Configuration Monitor - "Bank Information"

State Monitor - "Bank Rank"

Table Monitor - "Counter Desks"

Version Monitor - "Software Version"

Availability Monitor - "Open for Clients"

Long Monitor - "Served Clients"

Integer Monitor - "All Clients"

Frequency Monitor - "Transaction Frequency"

Quality-Rate Monitor - "Transactions Over 10,000 EUR"

Duration Monitor - "Transaction Duration"

Dynamically Installed Monitors

Template Installation

Installation of Template-Based Monitors

MBean Registration

Assigning Administrator Permissions

Using a Programmatic Interface to Create and Install Monitors Dy

Creating Configuration Groups

Creating a Simple Configuration Group

Creating a Configuration Configuration Group

Creating a Text Configuration Group

Creating a Version Configuration Group

Creating a Table Configuration Group

Creating a Duration Configuration Group

Creating a Frequency Configuration Group

Creating an Integer Configuration Group

Creating a Long Configuration Group

Creating a Quality-Rate Configuration Group

Creating a State Configuration Group

Installing Summary Nodes, Object Nodes and Monitors

Installation of Summary and Object Nodes

Installation of Monitors

Installation of Table and State Monitors

Uninstalling Summary Nodes, Object Nodes and Monitors

Customizing 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

Configuration Monitor

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

Programming Application Configuration Management

Connecting to the Configuration Manager

Opening a Configuration in Read or Write Mode

Opening the Application Configuration Root

Creating Sub-configurations

Modifying the Application Configuration

Exception Handling

Registering ConfigurationChangedListener

Defining Application Properties

Portal Runtime Technology

Portal Infrastructure

Portal Runtime API

Cache Control Interfaces

ICachablePortalComponent Interface

ICacheValidator Interface

ICacheDiscriminator Interface

ICacheResourceValidator Interface

Portal Runtime Cache

Portal Application Archives

PAR Files – Ways to Build

Class Loading in the Portal Runtime

PAR Files Deployment

Deploying a PAR File

Local Deployment

Defining a Logger Configuration

Application Example

Structure of the portalapp.xml

Portalapp.xml Example

Portal Application Lifecycle

Portals Security

Portal Object Name and Alias

Permission Model for Portal Components and Portal WEB Services

Security Zone and Safety Level

Implementation

Portal Runtime Architecture

Application Repository

Portal Request Cycle

Portal Component Modes

Portal Runtime Test Mode

Help Mode Implementation

Event Handling

SAP J2EE Application / Portal Runtime Application Interaction

Life Cycle

Executing a Servlet as Portal Component

Accessing Portal Applications from J2EE Applications

Accessing J2EE Applications from Portal Applications

Accessing Application, Library or Service

Referencing an Application, Library or Service

Packaging a Portal Application as Part of a J2EE Application

JNDI Support in PRT

Starting Portal Objects

Portal Content Abstraction

Web Services Support

Concepts and Architecture

SOAP Framework and Connection

SOAP Fault Process

Related Tools

Creating Web Services

Security on the Portal WEB Services

Examples of Portal Web Services Security

JSP Support

Declaring JSP as a Portal Component

JSP Selected Programmatically

JSP Packaging/Compilation

Accessible JSP Objects

Portal Runtime Extension

Tag Lib Packaging

Java Beans

Request Events Handling

SAP NetWeaver Developer Studio Plug-In

Configuring the Plug-In Tool

Configuring Global Project Settings

Creating a New Portal Application Project

Creating New Portal Components and Services

Creating a New Portal Service from a WSDL File

Managing PAR and JAR Files in the Project

Importing a Portal Application Project

Exporting a Portal Application Project to a PAR File

Portal Application Development Support of the Plug-In

Creating a Config Archive

Accessing Data

Configuring an Event Subscription

PAR Unit Test Studio

Enterprise Portal Web Services Checker Plug-in

Notification Service Example

Content Conversion Service

Content Converter Service

JCo Client Service

RFC Engine Service

PRT RFC Engine Service Integration

Calling Portal Services via RFC

Deployment Hook

Deployment Hook Interface

Deployment Handler

Text Localization and Portal Components Internationalization

Resource Bundle Access from a Portal Component

Locale Lookup

Resource Bundles

Request/Response Handling

Logger Configuration

Exception Handling

General Rules and Guidelines for Managing Exceptions

Log Viewer Tool

Developing Application Clients

Performing Lookup from Application Client

Packaging and Deploying Application Client

Deployment Services

Using DeployService Interface in Application Development

Using DeployService Interface in Java Clients

File Upload and Download

File Transfer Service API Example

Naming (JNDI)

Naming System Architecture

JNDI Registry Service Specific Features

Creating an InitialContext

SAP J2EE Engine Specific Environment Parameters

Local and Global Operations. Replication Methods.

An Algorithm for Execution of Local and Global Operations

JNDI Registry Service Cache

Lookup of SAP J2EE Engine Services

Integration with Other Services

SAP XML Toolkit for Java

Basic Concepts

XSL Overview

XSL Stylesheet Processing

JAXP Overview

XML Schema Validator

Java API for XML Parsing (JAXP)

DOM Basics

Building DOM Trees Through Parsing

Traversing

Building DOM Trees from a Document

Processing XML Using SAX

Using SAX Parser

ContentHandler and DefaultHandler Implementation

XSL Transformations

Output Properties

Transforming Without Stylesheet - Converting

Transforming Without Stylesheet

Advanced Techniques

Integration of XSL with Other Languages

Java Integration (Java Language Binding)

Integration with Scripting Languages

Multiple Output Documents

Active XML Scanning

Evaluating XPath Queries on DOM Objects

Using XML Schema with SAX

Loading JAXP Implementation

SAP XML Toolkit for Java FAQ

Mobile Enhancements

Mobile HTML-Business for Java

Mobile HTML-Business for Java – An Overview

Model View Controller Architecture – The Underlying Concept

Special Features of Web Controls for Mobile Applications

Using JSP Tags and Components Similar to Beans

Example: Displaying the tableView Web Control

Mobile Extensions to the Java Servlet Container

Differences Between Mobile Devices

Effects of the Differences Between WAP Browsers

Device Recognition

The ClientInfo Interface in the Java Servlet Engine

ClientInfo Interface

getAccept Method

isBackHardWired Method

getBackLabel Method

getBreakingSpace Method

getBrowserCategory Method

getBrowserName Method

getBrowserOS Method

getCharHeight Method

getCharWidth Method

isCookiesSupported Method

isCssSupported Method

getDefaultActionDesign Method

getDefaultBlockSeparator Method

getDefaultBullet Method

getDefaultFormStyle Method

getDefaultMenuStyle Method

getDeviceCategory Method

getDeviceName Method

getFieldsetLayout Method

isFieldsetTitleVisible Method

getFormFactor Method

isFormMenuSupported Method

isFramesSupported Method

isHrefWithParamsSupported Method

isInputShownWithCaption Method

isImageLinksSupported Method

isLinksSeparated Method

getLinkDecoration Method

getLinkTextWidth Method

isMarqueeLinkSupported Method

isMarqueeTextSupported Method

getMaxLinkLength Method

getMediaFormats Method

isNbspSupported Method

isNestedTablesSupported Method

isNewlineAfterImage Method

isNewlineAfterInput Method

isNewlineBeforeImage Method

isNewlineBeforeInput Method

isNewlineBeforeLink Method

isNewlineBetweenImages Method

isNewlineBetweenLinks Method

isNewlineBetwLinkAndTag Method

getPageSizeMax Method

getPixelHeight Method

getPixelWidth Method

isRedirRelativeSupported Method

isScriptSupported Method

isSelectionMenuSupported Method

isSkippingTolnput Method

getSoftkeyNum Method

getSoftkeyStyle1 Method

getSoftkeyStyle2 Method

getSoftkeyTitleWidth Method

getSubCategory Method

isTableHasBorders Method

isTableSupported Method

TelephonyLinksSupported Method

isTextStylesSupported Method

isTitleSupported Method

getTitleWidth Method

getUserAgent Method

The Administrator’s Guide to the Device Recognition Process

The Deployment Descriptor

Changing Deployment Descriptor Elements

Modifying Device Properties

Adding a New Mobile Device

XML Archive Application Programming Interface

Deployment: Putting It All Together

Software Deployment Manager

Working with the Graphical User Interface (GUI)

Starting and Stopping the Software Deployment Manager

Starting and Stopping the SDM (Windows)

Starting and Stopping the SDM (UNIX)

Running the SDM in Standalone Mode

Terminology

Deploy Tool

Basics of the Deploy Tool

Setting the Deploy Tool Properties

Shortcut Keys

Additional Functions

Saving a Project

Refreshing the Deploy Tool

Setting a Project Classpath

Setting Classpath Variables

Removing a Component

File Chooser Window

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

Deployment API

Deploying a J2EE Application

DeployExample.java

Converter Tool

Connectivity and Interoperability

SAP Java Connector

SAP JCo Architecture

SAP JCo Functions

SAP JCo Scenario: J2EE/ABAP Coupling (SAP Web AS)

SAP Java Resource Adapter

SAP JRA Architecture

SAP Enterprise Connector

Programming Model

Proxy Generation

Example: Using Generated Proxies to Call Function Modules

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

Remote Objects Garbage Collection

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

Failover for Clustered RMI-P4 Remote Objects

Developing Failover-ready RMI-P4 Applications

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

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

The SAP NetWeaver Developer Studio: Security Aspects