SAP Library - SAP NetWeaver Composition Environment Library

SAP NetWeaver Composition Environment Library

What's New in Enhancement Package 1 for SAP NetWeaver CE 7.1

What's New in Enhancement Package 1 SP1 (Ramp-Up Start)

Development Infrastructure

NWDI Development

Composition

Enterprise Services Repository and Registry

Modeling and Design

Composite Application Framework

Business Process Management

Business Rules Management

Portal

Portal Usage and Administration

Running Content in a Remote Portal

Portal Content Modeling

Visual Composer in SAP NetWeaver Developer Studio

Guided Procedures

Security

User Authentication and Single Sign-On

Web Services Security

System Security

What's New in Enhancement Package 1 SP2

What's New in Enhancement Package 1 SP3

What's New in Enhancement Package 1 SP4

What's New in Enhancement Package 1 SP5

What's New in Enhancement Package 1 SP6

What's New in Enhancement Package 1 SP7

What's New in Enhancement Package 1 SP8

What's New in Enhancement Package 1 SP9

What#s New in Enhancement Package 1 SP12

Release Notes for AS Java

Administrator's Guide

Architecture of AS Java

Configuration of SAP NetWeaver CE

Administration of SAP NetWeaver CE

SAP NetWeaver CE Security Guide

Developing Applications Using Java

SAP NetWeaver Developer Studio Basics

Starting the Developer Studio

Setting Workspace Using the -data Parameter

Setting the Java VM Using the -vm Parameter

Changing the Default Workspace

Starting the Developer Studio Using a Batch File

Using Other Start Parameters

Update Manager

Viewing the Error Log File

Working with the Developer Studio

SAP's Component Model

Creating and Modifying Projects

Using Different Java Runtime Environment Versions

Referencing Libraries

Testing Java Applications with JLin

Creating and Editing Variants

Executing JLin Tests

Displaying JLin Results

Executing JLinEE Tests

Testing Web Dynpro Applications

Test Scripts and Test Results

Recording a Test Script in the Developer Studio

Replaying a Test Script in the Developer Studio

Comparing Scripts and Results

Administering AS Java from the Developer Studio

Starting and Stopping SAP Systems

Viewing the Communication Ports

Monitoring the Application Server with the SAP Management Consol

Starting and Stopping Components

Enabling and Disabling the Debug Mode

Viewing Log and Trace Files

Changing Log Configuration

Recording Issues with the Support Session

Creating and Examining Snapshots

Reference

Layout of the SAP Management Console

Context Menus and Settings of the SAP Management Console

Administration Using Telnet

Development Technologies

Developing Java EE 5 Applications

Getting Started

Configuring the Application Server in the Developer Studio

Developing Your First Java EE 5 Application

Developing the EJB 3.0 Module

Developing the Web Module

Deploying and Running the Enterprise Application

Concepts

Java EE 5 Development Tools

Java EE Perspective

JPA Development Perspective

Deploy Perspective

Java Enterprise Edition 5 Overview

Overview of the Java Persistence API

Entities

Entity Manager

Entity Manager Operations

Relationships

Relationships Mapping Principles

Cascading Entity Manager Operations

Native Databases with Foreign Key Constraints

Queries

JPQL Queries on a Native SQL Execution Layer

Generated Primary Keys

Inheritance

The persistence.xml File

Running JPA Applications on the System Data Source

Versioning and Dirty Reads

Caches in the JPA Implementation

Web Services

JavaServer Faces

Application Server's Robustness and High Availability

Tasks

Developing Persistence

Overview of the Java Persistence Infrastructure

Using JPA in the Persistence Layer

Creating Connections to the Java Dictionary

Creating Database Connections

Creating JPA Projects in the Developer Studio

Creating Entities and Generating Database Tables

Creating Database Tables and Generating Entities

Working with the Entity Manager

Obtaining an Entity Manager Instance

Managing Entity Instances

Creating and Executing Queries

Configuring the Persistence Unit in the persistence.xml

Using Open SQL/JDBC in the Persistence Layer

Getting a Connection to the Database

Inserting Data Into a Table

Using Queries

Semantics of the Data Types DATE, TIME, and TIMESTAMP

Transactions in Open SQL/JDBC

Native SQL Access

Error Handling

Using Open SQL for Java Features

Table Buffer

Buffer Granularity

Statements Using the Buffer

Statements Bypassing the Buffer

Modifications and Actions on the Remote Buffers

Reading and Writing LOBs En Bloc

Using Locators

Using Streams

Numbers

DATE, TIME and TIMESTAMP Values

Value Checker API

Handling Transactions and Resources in Applications

Introduction to Transactions in AS Java

JTA Implementation

JTS Implementation

JTA and Local Transactions

Using Container-Managed JTA Transactions

Using Component-Managed JTA Transactions

Using Local Transactions

Two-Phase Commit

Transaction Synchronization Registry

Resource Handling Mechanism

Connection Handling in JTA and Local Transactions

Sharing Connections

Database Connection Management

Locks

Enqueue Locks

Working with Enqueue Locks

Locking Protocols

Working with the TableLocking API

Setting Locks with the TableLocking API

Releasing Locks with the TableLocking API

Working with the LogicalLocking API

Getting a LogicalLocking Instance

Setting Locks with the LogicalLocking API

Releasing Locks with the LogicalLocking API

Reconnecting to the DB in the Event of a DB Crash

Developing Business Logic with EJB 3.0

EJB Overview

Creating EJB 3.0 Projects in the Developer Studio

Creating Session Beans in the Developer Studio

Setting a Session Timeout

Creating Message-Driven Beans in the Developer Studio

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

Using Dependency Injection

Editing EJB Environment

Specifying Transaction Attributes

Specifying Security

Using Interceptors and Life Cycle Callbacks

Using Java Persistence API (JPA)

Using Enterprise JavaBeans as Web Service Endpoints

Editing the ejb-j2ee-engine.xml

Accessing Enterprise JavaBeans from Remote Clients

Using Timers

Developing User Interfaces

Creating Dynamic Web Projects

Using Annotations in Web Applications

Annotations in Web Applications

Injecting EJB Resources into Web Applications

Injecting Resources into Web Applications

Accessing Persistence in Web Applications

Configuring Methods Using Annotations in Web Applications

Configuring Security Roles Using Annotations in Web Applications

Developing JavaServer Faces (JSF) Web Applications

Creating the JSF UI Components

Creating JSF JSP Files

Standard JSF Tags

Dynamic Data Tables

Command Buttons

Validating User Input

Managed Beans

faces-config.xml

Using the SAP Component Library for JSF

Developing Servlets

Creating Servlets in the Developer Studio

Initializing Servlets

Servicing Client Requests

Retrieving Client Input

Retrieving Multipart Request Messages

Request Attributes When Using Application Zones

Obtaining the Remote Host Address

Composing HTTP Responses

HTTP Response over Persistent Connections

IOException in Cases When Client Closes Connection

Threadsafe Servlets

Handling Cookies in Servlets

Setting Cookies in HTTP Servlets

Retrieving Cookies from the HTTP Request

AS Java Cookies

Servlet-defined Cookies

HTTP Sessions

Lifetime of a Session

Session Tracking with Servlets

Accessing and Manipulating the Session Object

Terminating a Session

URL Rewriting as an Alternative to Cookies

HTTP Sessions and Failover of Web Applications

Dispatching Requests to Web Application Resources

Including Requests

Forwarding Requests

Destroying Servlet Instances

Developing Event Listeners

Developing Filters

Developing JSP Pages

Creating JSP Files in the Developer Studio

JSP Life Cycle

Syntax Elements Outline

Using the page Directive

Implicit Objects

Standard Actions

Including and Forwarding Requests in a JSP

JSTL

Developing Custom Tags

Developing Classic Tag Handlers

Developing Simple Tag Handlers

Developing TLD Files

Describing Tag Handlers in TLD Files

Developing Tag Files

Describing Tag Files in TLD Files

Unified Expression Language

EL Expressions in Tag Attribute Values

Deferred Expressions Evaluation

Using EL Implicit Objects

Developing EL Functions

Developing Portlets

Portlet Life Cycle

Implementing the Portlet Interface

Extending the GenericPortlet

Initializing Portlets

Servicing Action Requests

Servicing Render Requests

Portlet Preferences

Portlet Sessions

Dispatching Requests to Servlets and JSPs

User Information

Packaging and Deployment Descriptor

Portlet Tag Library

Editing the web-j2ee-engine.xml

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

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

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

Creating and Configuring Web Services and Web Service Clients

Providing Web Services

Providing Web Services Inside Out

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

Creating an Inside-Out Web Service from a Java Class

Service Endpoint Interface

Providing Web Services Outside In

Importing WSDL Documents in the SAP NetWeaver Developer Studio

Creating Outside-In Web Services

Collision Resolution and Global Customizations

Using Interactive Conflict Resolution

Using Automatic Conflict Resolution

Using JAX-WS Customization Files

Using No Customizations

Global Customizations

Browsing Enterprise Services from the SAP NetWeaver Developer St

Providing a TU&C/C Web Service

Configuring Web Services at Design Time

Setting an Authentication Level

Setting the Transport Guarantee Level

Configuring a One Way Message Exchange Pattern

Configuring Web Services Reliable Messaging

Configuring URLs for Web Service Endpoints

Configuring Stateful Communication

Connecting the SAP NetWeaver Developer Studio to the Services Re

Adding Classifications to Web Services

Viewing Web Service Artifacts

Editing the Properties of Web Service Artifacts

Restrictions to Web Service Implementation Beans

Consuming Web Services

Creating Web Service Proxies

Creating Service Groups

Creating Shared Service Groups

Creating Private Service Groups

Creating Predefined Service Groups

Creating Classified Service Groups

Editing Service Groups and Service References

Creating Web Service Client Applications

Consuming TU&C/C Web Services

Consuming Idempotent Web Services

Extended Proxy Capabilities

Web Service Providers and Consumers for Brokered Communication

Web Service Providers for Brokered Communication

Web Service Consumers for Brokered Communication

Creating and Configuring XI 3.0-Compatible Web Service Providers

Creating and Configuring Web Service Providers

Creating Web Service Providers for Brokered Communication

Application Program Interface for Inbound Proxy Communication

Creating and Configuring Web Service Consumers

Creating Web Service Consumers for Brokered Communication

Application Program Interfaces for Outbound Proxy Communication

Configuring Web Service Consumers for Brokered Communication

Configuring Web Services and Web Service Clients in the SAP NetW

Concepts

Connection to Provider Systems

Configuration of Individual Web Services and Web Service Clients

Configuration of Groups of Web Services

Configuration of Groups of Web Service Clients

Service Metering

Service Metering for Non-SAP Service Consumers

Configuration of Destinations to Provider Systems

Preparing Communication Profiles

Creating Connections to Provider Systems

Creating User Accounts

Assigning User Accounts

Configuring Web Services

Configuring Groups of Web Services

Configuring Web Services Exposed by Applications

Grouping and Configuring Web Services in Business Scenarios

Configuring Individual Web Services

Managing WSDL Documents

Accessing Information Provided via WSIL

Configuring Web Service Clients

Configuring Groups of Web Service Clients

Configuring Consumer Applications

Configuring the Consumer Side of Business Scenarios

Configuring Individual Web Service Clients

Creating Web Service Physical Destinations

Configuring SAP NetWeaver Administrator

Configuring Proxy Settings

Configuring Reverse Proxy Settings

Configuring Host Mapping, Path Prefix, and Path Mapping

Mappings for Host and Port

Mappings for URL Published in Services Registry

Path Mappings

Configuring Web Services Navigator White List

Modifying SOA Configuration Background Process Settings

Testing Web Services in the Web Services Navigator

Testing Services Manually

Finding Web Services

Testing a Web Service Operation

Changing Invocation Parameters

Testing Services Using Test Scenarios

Creating a Test Scenario

Executing a Test Scenario

Editing a Test Scenario

Publishing to the Services Registry

Publishing Web Services from the SAP NetWeaver Administrator

Publishing Service Groups from the SAP NetWeaver Administrator

Viewing Web Services Logs and Traces

Supported Specifications

Tutorials

Developing a HelloWorld Web Service

Creating the HelloWorld Web Service

Creating an Enterprise Java Bean Project for the HelloWorld Web

Creating the Enterprise Java Bean

Exposing the Enterprise Java Bean as a Web Service

Deploying the HelloWorld Web Service

Testing the HelloWorld Web Service

Creating the HelloWorld Web Service Client

Creating a Dynamic Web Project for the Web Service Client

Importing the WSDL Document

Generating the Web Service Proxy

Creating the Web Service Client Application

Deploying the HelloWorld Web Service Client

Exposing and Configuring the Converter Application as a Web Serv

Exposing the Converter Application as a Web Service

Importing the Converter Application in the SAP NetWeaver Develop

Exposing the Implementation EJB as a Web Service

Setting an Authentication Level to the Web Service

Deploying the Converter Web Service

Configuring the Web Service in the SAP NetWeaver Administrator

Testing the Converter Web Service

Creating the Converter Web Service Client

Creating a Dynamic Web Module for the Converter Consumer Applica

Importing the Converter WSDL Document

Generating the Converter Web Service Proxy

Generating the Converter Service Group

Creating the Converter Web Service Client Application

Deploying the Converter Web Service Client

Configuring the Web Service Client in the SAP NetWeaver Administ

Setting Severity to Web Services and Web Service Clients

Starting the Converter Web Service Client Application

Viewing Converter Web Service and Web Service Client Logs and Tr

Using Java Message Service

JMS Overview

JMS Clustering and Failover

Creating and Configuring JMS Virtual Providers

Creating and Configuring JMS Resources and Resource References

Property Reference

Accessing JMS Resources

Using JMS Resources from Two and More Applications

Creating Message Producers and Consumers

Using Queue Browsers

Using Durable Subscriptions

Using Message Selectors

Message Selector Syntax

Consuming Messages from Message-Driven Beans

Processing Messages

Handling Dead Messages

Using Transactions

Configuring Transaction-Related JMS Connection Factory Propertie

Using a Third-Party JMS Provider

Using JMS Store-and-Forward

Monitoring JMS Provider Using Telnet

Handling Exceptions

Example

Developing JCA Resource Adapters

Creating Connector Projects in the Developer Studio

Implementing 1.5 Resource Adapter

What's New in JCA 1.5

The Resource Adapter JavaBean

Outbound Communication

Inbound Communication

Message Endpoint Activation

Message Inflow Scenario

Transaction Inflow Support Implementation

Implementing the Work Management Contract

Implementing 1.0 Resource Adapter

Implementing Connection Management

Implementing Transaction Support

Implementing Interaction Functions

Assembling and Configuring the Resource Adapter

Resource Adapter Archive (RAR)

ManagedConnectionFactory Configuration

Resource Adapter Transaction Support

Connection Pooling

Resource Adapter Classloading

Using Resource Adapter to Obtain a Connection

Driving an Interaction with the EIS

Developing Application Clients

Working with Libraries

Using Shared Libraries

Using Bundled Libraries

Migrating Old Library Projects

Using Heavy Class Loaders

Heavy Loaders

Assembling Components into Enterprise Applications

Creating Enterprise Application Projects

Adding Modules to the Enterprise Application

Using Bundled Libraries

Adding the application.xml to Enterprise Application Projects

Editing the application-j2ee-engine.xml

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

Deploying Applications

Security Actions Necessary to Perform Deploy Operations

Deploying and Undeploying with SAP NetWeaver Developer Studio

Building, Publishing and Removing Published Java EE Applications

Deploying Archives

Working with Deploy Templates

Managing Deployed Archives

Undeploying Archives

Managing Substitution Variables

Viewing Deployment Related Logs

Filtering and Sorting Archives

Deploying Applications with Third-Party Deployment Tools

Using Ant Scripts to Work with SDAs

Using Shell Scripts to Work with SDAs

Managing the Application Environment

Creating Your Own Application Tables in the Database

demotables.sql

Working with Data Sources

Deploying Data Sources

Data Source Example

Deploying Data Source Aliases

Deploying JDBC Drivers

Creating J2EE 1.4 Applications in SAP NetWeaver Developer Studio

Creating J2EE 1.4-Compliant Web Components

Creating EJB 2.1 Components

Assembling J2EE 1.4-Compliant Enterprise Applications

Debugging Java EE Applications

Configuring AS Java for Debugging

Creating Debug Configurations in the Developer Studio

Stopping Remote Debugging

Creating Platform-independent Java EE Applications

Migrating Existing Java EE Applications to AS Java

Using AS Java APIs

Using JavaMail

Obtaining a Session Object

Creating E-Mail Messages

Sending E-Mail Messages

Receiving E-Mail Messages

Creating Secure Connections Using JavaMail

HTTP Client

HTTP Client Properties

Simple Get Request to a Specified Host and Port

Get Request Using Proxy

Posting File Using Chunked Encoding

Get Request Using Basic Authentication

Managing System and Application Configurations

Configuration Manager

Monitoring Configurations

Java Configuration Browser

Adding Configuration Capabilities to an Application

Connecting As an AS Java Application

Deploying Properties Within an Application

Accessing Application Properties

Registering a Property Change Listener

Modifying Application Properties

Accessing the System Profile

Naming and Directory Services (JNDI)

JNDI Registry Service

Creating an Initial Context

Binding Objects

Looking up Objects

Browsing the Naming Tree

JNDI Browser

NAMING Shell Commands

Using JNDI Registry Service to Locate Resources

RMI-P4 Overview

Developing Distributed Applications Based on RMI-P4

Defining a Remote Interface

Implementing the Remote Interface

Binding the Implementation to the Naming System

Implementing a Client

Accessing Enterprise JavaBeans from Remote Clients

RMI-P4 Reference

Using P4 Protocol Over a Secure Connection

Network Configuration for RMI-P4

Advanced P4 Protocol Connection Configuration

RMI-P4 Specific InitialContext Properties

Reference

Deployment Descriptors

appclient-j2ee-engine.xsd

application-j2ee-engine.xsd

connector-j2ee-engine.xsd

ejb-j2ee-engine.xsd

ejb-j2ee-engine_3_0.xsd

data-source-aliases.dtd

Tutorials

Project Management and Employee Services Application

Running the Application

Setting Up Application Users

Running the Predeployed Application

Deploying and Running the Application from NWDS

Application Data Model

Developing a Simple Java EE 5 Application

Creating the Development Components

Creating and Adjusting the JPA Entities

Creating the Project and Employee Entities

Adjusting the JPA Entities

Preparing the Data Source and Generating Tables

Developing the Business Logic Layer

Developing the User Interface Layer

Adjusting the Web DC and Creating the JSP Skeleton

Implementing the Managed Bean

Implementing (Designing) the Application JSPs

Preparing, Deploying and Running the Application

Reference

ListProjects JSP Source Code

EditProject JSP Source Code

SetProjectEmployees JSP Source Code

Default JSP Source Code

ListEmployees JSP Source Code

EditEmployee JSP Source Code

Menu JSP Source Code

Managed Bean (ProjectMB) Source Code

Project Facade Source Code

Project Source Code

Employee Source Code

Developing a Message-Driven Bean Application

Creating an EJB 3.0 Project and an EAR Project

Developing the Message-Driven Bean

Configuring the JMS Resources

Deploying the EAR

Sender JMS Client Example

Running the Example

Developing an Application Client

Creating and Implementing an EJB 3.0 Project

Creating and Implementing the Application Client

Deploying the Application

Running the Application Client

Creating an Adaptive RFC2 Sample Application without using Web D

Java Persistence Reference

Overview of the JDBC API

JDBC Java Packages

java.sql

javax.sql

JDBC Java Classes and Interfaces

java.sql.Blob

java.sql.Clob

java.sql.Connection

java.sql.DatabaseMetaData

java.sql.Driver

java.sql.PreparedStatement

java.sql.ResultSet

java.sql.ResultSetMetaData

java.sql.Statement

Open SQL Reference

Open SQL Database Dependencies

Delimited Identifiers

SELECT FOR UPDATE Statement

Value expressions

Column References

Set Functions

Arithmetic Expressions

Dynamic Parameter Specification

Search Condition

Comparison predicate

Scalar Subqueries

Quantified comparison predicate

Data Type Conversion Tables

Mapping JDBC Types to Java Types

Type Conversions Supported by ResultSet Getter Methods

Type Conversions Supported by PreparedStatement Setter Methods

Open SQL Type Propagation

Providing Java Dictionary Tables and Data Types

Creating Dictionary Development Components

Creating Data Types

Initial Values

Creating Structures

Specifying Reference Fields

Creating Tables

Buffering Type

Creating Indexes

Specifying Database Specific Parameters

Database Specific Parameters for MS SQL Server

Database Specific Parameters for DB2 for Z/OS

Database Specific Parameters for DB2 for Linux, Unix and Windows

Database Specific Parameters for Oracle

Creating Views

Deploying Dictionary Development Components

Editing Table Definitions

Extracting Database Content

Configuring the Dictionary Perspective

Integrating Security Functions

Protecting Applications

Getting Started

Concepts

Approaches to Protecting Applications

Declarative and Programmatic Authorization

Named Permissions and Action Permissions

Tasks

Protecting Java Web Applications

Specifying Authentication for Java Applications

Specifying Authentication Mechanisms for Java Applications

Creating Application Roles for Web Access

Creating a Security Constraint

Protecting Web Dynpro Applications

Creating Development Components for UME Actions

Creating UME Actions

Checking Permissions

Getting the Current User

Logging Off Applications

Developing Authentication Enhancements on the AS Java

Overview of the Login Process in JAAS

Integration of AS Java and UME Authentication

Using Login Modules to Protect Web Applications

Configuring Authentication

Using the HTTP Callback Classes

SAP Specific HTTP Callbacks

Changing the User Password

Single Sign-on for Web Applications

Security Sessions

Security Aspects for Web Services

Remote Authentication

Propagating Security Principals between Application Containers

Tasks

Developing a Custom Logon Screen

Create and Configure a Login Module

Creating and Implementing the Login Module

Creating a New Java Project

Setting Required Classpaths to Compile the Java Project

Implementing the Login Module Source Code

Exporting the Login Module Class in a JAR File

Creating and Implementing the Configuration File

Preparing the Login Module for Deployment

Creating a New Enterprise Application

Exporting a Deployable EAR File

Adding the JAR File and the Configuration File to the EAR File

Deploying the EAR to the AS Java

Configuring the Login Module on the AS Java

Example Login Module

Integrating the Virus Scan Interface

Getting Started

Implementing a Virus Check

Destination Service API

Interfaces and Classes for Using the Destination Service API

Examples for Using the Destination Service API

Secure Connection Factory API for HTTPS Clients

Interfaces and Classes for Using the Secure Connection Factory

Examples for Using the Secure Connection Factory

Digital Signatures and Document Encryption API

Interfaces and Classes for Using Digital Signatures and Encrypti

Examples for Using Digital Signatures

Adding User Management Functions to Applications

Concepts

Standard Search and Simple Search

Tasks

User Management Functions for Users

Creating Users

Editing Common User Attributes

Editing Custom and Other User Attributes

Searching for Users with Standard Search

Searching for Users with Simple Search

Displaying Users

Deleting Users

User Management Functions for Groups

Creating Groups

Assigning Users to Groups

Editing Group Attributes

Searching for Groups with Standard Search

Searching for Groups with Simple Search

Displaying Groups

Deleting Groups

User Management Functions for Roles

Creating Roles

Assigning Users to Roles

Editing Role Attributes

Searching for Roles with Standard Search

Searching for Roles with Simple Search

Displaying Roles

Deleting Roles

Using Central Development Services

Providing Java Dictionary Tables and Data Types

Creating Dictionary Development Components

Creating Data Types

Initial Values

Creating Structures

Specifying Reference Fields

Creating Tables

Buffering Type

Creating Indexes

Specifying Database Specific Parameters

Database Specific Parameters for MS SQL Server

Database Specific Parameters for DB2 for Z/OS

Database Specific Parameters for DB2 for Linux, Unix and Windows

Database Specific Parameters for Oracle

Creating Views

Deploying Dictionary Development Components

Editing Table Definitions

Extracting Database Content

Configuring the Dictionary Perspective

Integrating Security Functions

Protecting Applications

Getting Started

Concepts

Approaches to Protecting Applications

Declarative and Programmatic Authorization

Named Permissions and Action Permissions

Tasks

Protecting Java Web Applications

Specifying Authentication for Java Applications

Specifying Authentication Mechanisms for Java Applications

Creating Application Roles for Web Access

Creating a Security Constraint

Protecting Web Dynpro Applications

Creating Development Components for UME Actions

Creating UME Actions

Checking Permissions

Getting the Current User

Logging Off Applications

Developing Authentication Enhancements on the AS Java

Overview of the Login Process in JAAS

Integration of AS Java and UME Authentication

Using Login Modules to Protect Web Applications

Configuring Authentication

Using the HTTP Callback Classes

SAP Specific HTTP Callbacks

Changing the User Password

Single Sign-on for Web Applications

Security Sessions

Security Aspects for Web Services

Remote Authentication

Propagating Security Principals between Application Containers

Tasks

Developing a Custom Logon Screen

Create and Configure a Login Module

Creating and Implementing the Login Module

Creating a New Java Project

Setting Required Classpaths to Compile the Java Project

Implementing the Login Module Source Code

Exporting the Login Module Class in a JAR File

Creating and Implementing the Configuration File

Preparing the Login Module for Deployment

Creating a New Enterprise Application

Exporting a Deployable EAR File

Adding the JAR File and the Configuration File to the EAR File

Deploying the EAR to the AS Java

Configuring the Login Module on the AS Java

Example Login Module

Integrating the Virus Scan Interface

Getting Started

Implementing a Virus Check

Destination Service API

Interfaces and Classes for Using the Destination Service API

Examples for Using the Destination Service API

Secure Connection Factory API for HTTPS Clients

Interfaces and Classes for Using the Secure Connection Factory

Examples for Using the Secure Connection Factory

Digital Signatures and Document Encryption API

Interfaces and Classes for Using Digital Signatures and Encrypti

Examples for Using Digital Signatures

Adding User Management Functions to Applications

Concepts

Standard Search and Simple Search

Tasks

User Management Functions for Users

Creating Users

Editing Common User Attributes

Editing Custom and Other User Attributes

Searching for Users with Standard Search

Searching for Users with Simple Search

Displaying Users

Deleting Users

User Management Functions for Groups

Creating Groups

Assigning Users to Groups

Editing Group Attributes

Searching for Groups with Standard Search

Searching for Groups with Simple Search

Displaying Groups

Deleting Groups

User Management Functions for Roles

Creating Roles

Assigning Users to Roles

Editing Role Attributes

Searching for Roles with Standard Search

Searching for Roles with Simple Search

Displaying Roles

Deleting Roles

SAP NetWeaver Scheduler for Java

Architecture

Scheduler Job Definition, Job, and Task

Developing and Scheduling Jobs

Job Definition

JobBean Class

Deployment Descriptors

Job Scheduling Through the Scheduler API

Getting a JNDI Reference to the Scheduler API

Scheduling Jobs with Recurrent Start Conditions

Scheduling Jobs with Cron Start Conditions

Example: CronEntry

Excluding Scheduled Job Executions from a Scheduler Task

Reference

Scheduler Job Start Conditions

Scheduler Job Statuses

Job-definition.dtd

Job Parameter

Example: Job Parameters

Server Downtime, Daylight saving time, and Time Shift

Creating and Scheduling Your First Job

Hello Job

Creating the Hello Job Definition

Creating an EJB Project

Creating a Message-Driven Bean

Setting the Build Path

Developing the JobBean Class of the HelloJob

Extending the JobBean Class with Job Parameters

Editing the ejb-j2ee-engine.xml

Creating and Editing the job-definition.xml

Editing the application-j2ee-engine.xml

Deploying the HelloJob

Scheduling the HelloJob

Creating a Scheduler Task for the HelloJob

Scheduling Jobs Using the SAP NetWeaver Scheduler for Java

Working with Jobs

Working with Tasks

Creating a Scheduler Task

Setting Recurring Start Conditions

Setting Cron Start Conditions

Setting Simple Start Conditions

Viewing Job Definitions

Developing Logging-Enabled Applications

Logging Overview

How to Write Log and Trace Messages

Logging

Addressees of Log Messages

How to Use Categories

Types and Content of Log Messages

Severities for Log Messages

Tracing

Addressees of Trace Messages

How to Use Locations

Types and Content of Trace Messages

Severities for Trace Messages

SAP Logging API

Overview

Sample Java Code with Logging

Coding Recommendations

Enabling Logging for Applications

Identify the Output: Location or Category

Enable Output Messages

Message Output with Severity

Program Flow for a Location

The Master Gate

SimpleLogger Class

Basic Configuration Features

Log (Destination)

Formatter

Filter

Hierarchical Destination Inheritance

Severity Evaluation

Output File

Advanced Configuration Features

Relations Between Category and Location

Multi-Threading

Configuration Tool

Calling the Configuration Tool

Syntax and Semantics of the Properties File

Support of Periodic Reloading

Summary Highlights

Tips and Tricks

Administrative Issues

Appendix A: Severity Levels

Appendix B: Classes Hierarchy

Appendix C: Default Behavior of Certain Objects

Sample Logging Tutorial

Creating an EJB Project for the HelloWorld Application

Creating the HelloWorld EJB

Exposing the EJB as a Web Service

Implementing Logs in the HelloWorld Application

Deploying the HelloWorld Application

Testing the HelloWorld Application

Viewing Logs of the HelloWorld Application

Enabling Applications with Monitoring

Enabling Standard Application Resources Administration

JMX Service Interface

Architecture

Writing MBeans

Connecting to an MBeanServer

MBean Registration

Access to an MBean

Query MBeans

Receiving Notifications

JMX Client Structure

Administration Adapter Service

Java Application Monitoring

Monitoring Concept

Monitors Inside the Monitoring Tree

Monitoring Resources with the Monitoring Framework

The monitor-configuration.xml

Template Monitors

Using Template Monitors

Instrumenting an Application to Provide Monitoring Data

Creating and Editing Monitors

Acquiring a Reference to the MBean Server

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

Registering the MBean

Sending Monitoring Data Actively Via JMX Notifications

Instrumenting the Application

Example of Application Instrumented with Monitoring

Designating the Variables You Want to Monitor

Developing the Resource MBean and the monitor-configuration.xml

Creating the Bank Name Text Monitor

Creating the Bank Information Configuration Monitor

Creating the Bank Rank State Monitor

Creating the Counter Desks Table Monitor

Creating the Software Version Version Monitor

Creating the Open for Clients Availability Monitor

Creating the Served Clients Long Monitor

Creating the All Clients Integer Monitor

Creating the Transaction Frequency Frequency Monitor

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

Creating the Transaction Duration Duration Monitor

Dynamically Installed Monitors

Installing the Template

Installing the Template-Based Monitors

Registering the MBean

Assigning Administrator Permissions

A Programmatic Interface that Creates and Installs Monitors Dyna

Configuration Groups

Simple Configuration Group

Configuration Configuration Group

Text Configuration Group

Version Configuration Group

Table Configuration Group

Duration Configuration Group

Frequency Configuration Group

Integer Configuration Group

Long Configuration Group

Quality-Rate Configuration Group

State Configuration Group

Summary Nodes, Object Nodes and Monitors

Installation of Summary and Object Nodes

Installation of Monitors

Installation of Table and State Monitors

Uninstallation of Summary Nodes, Object Nodes, and Monitors

Customization of Configuration Groups Using Third-Party Tools

Retrieving Monitoring Data from an External Client via JMX

Performance Monitors and Their Methods

Non-Performance Monitors and Their Methods

Using the Generic Configuration Reporter

Types of Monitors and Their Usage

Configuration Monitor

SAP Java Resource Adapter

SAP JRA for SAP Java Applications

SAP JRA Architecture

SAP JRA Configuration

SAP JRA Configuration: Procedure

SAP JRA Development Guidelines

SAP JRA Configuration on the Application Server Java

Client Programming Model

Transactions for the Client Programming Model

LocalTransaction

UserTransaction

Container Managed Transaction

Security for the Client Programming Model

BasicPassword

Kerbv5 (SSO)

DefaultAuthentication

Application Managed Authentication

Secure Network Connection (SNC)

Server Programming Model

Callback

Stateful Communication

Security for the Server Programming Model

Facades and Compilation

IDoc Support for Java Applications

Example Program IDoc Client

Example Program IDoc Server

Administering AS Java from the Developer Studio

Starting and Stopping SAP Systems

Viewing the Communication Ports

Monitoring the Application Server with the SAP Management Consol

Starting and Stopping Components

Enabling and Disabling the Debug Mode

Viewing Log and Trace Files

Changing Log Configuration

Recording Issues with the Support Session

Creating and Examining Snapshots

Reference

Layout of the SAP Management Console

Context Menus and Settings of the SAP Management Console

Administration Using Telnet

Important Disclaimers on Legal Aspects