SAP-Bibliothek - Developing Java EE 5 Applications

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 Module

Developing the Web Module

Deploying and Running the Application

Concepts

Java EE 5 Development Tools

Java EE Perspective

JPA Perspective

Deployment Perspective

Java Enterprise Edition 5 Overview

Overview of the Java Persistence API

Entities

Entity Manager

Entity Manager Operations

Relationships

Relationships Mapping Principles

Cascading Entity Manager Operations

Native Databases with Foreign Key Constraints

Queries

JPQL Queries on a Native SQL Execution Layer

Generated Primary Keys

Inheritance

persistence.xml

Running JPA Applications on the System Data Source

Versioning and Dirty Reads

Caches in the JPA Implementation

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 persistence.xml

Lazy-Loading Entities with Single-Valued Relationships

Creating Data Models with the JPA Diagram Editor

Open SQL / JDBC

Verbindung zur Datenbank

Einfügen von Daten in eine Tabelle

Selektion von Daten aus einer Datenbank

Semantik der Datentypen DATE, TIME und TIMESTAMP

Transactions in Open SQL/JDBC

Native SQL

Fehlerbehandlung

Relationale Persistenz

Table Buffer

Buffer Granularity

Statements Using the Buffer

Statements Bypassing the Buffer

Modifications and Actions on the Remote Buffers

Reading and Writing LOBs En Bloc

Using Locators

Using Streams

Numbers

DATE, TIME, and TIMESTAMP Values

Value Checker API

Handling Transactions and Resources in Applications

Introduction to Transactions in AS Java

JTA Implementation

JTS Implementation

JTA and Local Transactions

Distributed Transactions

Using Local Transactions

Two-Phase Commit

Transaction Synchronization Registry

Resource Handling Mechanism

Connection Handling in JTA and Local Transactions

Database Connection Management

JTA Transaction Recovery

Configuring the Transaction Service

Transaction Service Properties

Using Container-Managed JTA Transactions

Using Component-Managed JTA Transactions

Sharing Connections

Monitoring Distributed Transactions

Working with the TableLocking API

Sperren setzen

Sperren freigeben

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

EJB Environment

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

Specifying Transaction Attributes

Specifying Security

Using Interceptors and Life Cycle Callbacks

Using Java Persistence API (JPA)

Using Session Bean CRUD Facade Template

Using CRUD Application Template

Using Enterprise JavaBeans as Web Service Endpoints

Editing the ejb-j2ee-engine.xml

Using Timers

Testing Applications' Business Logic Using the EJB Explorer

Binding the Life Cycle of Application and Business Components

Accessing Enterprise JavaBeans from Remote Clients

Connecting to Enterprise Beans on SAP NetWeaver 2004 AS Java and

Developing User Interfaces

Creating Dynamic Web Projects

Using Annotations in Web Applications

Annotations in Web Applications

Injecting EJB Resources into Web Applications

Injecting Resources into Web Applications

Accessing Persistence in Web Applications

Configuring Methods Using Annotations in Web Applications

Configuring Security Roles Using Annotations in Web Applications

Developing JavaServer Faces (JSF) Web Applications

Creating the JSF UI Components

Creating JSF JSP Files

Standard JSF Tags

Dynamic Data Tables

Command Buttons

Validating User Input

Managed Beans

faces-config.xml

Using the SAP Component Library for JSF

Developing Servlets

Creating Servlets in the Developer Studio

Initializing Servlets

Servicing Client Requests

Retrieving Client Input

Retrieving Multipart Request Messages

Request Attributes When Using Application Zones

Obtaining the Remote Host Address

Composing HTTP Responses

HTTP Response over Persistent Connections

IOException in Cases When Client Closes Connection

Threadsafe Servlets

Handling Cookies in Servlets

Setting Cookies in HTTP Servlets

Retrieving Cookies from the HTTP Request

AS Java Cookies

Servlet-defined Cookies

HTTP Sessions

Lifetime of a Session

Session Tracking with Servlets

Accessing and Manipulating the Session Object

Terminating a Session

URL Rewriting as an Alternative to Cookies

HTTP Sessions and Failover of Web Applications

Dispatching Requests to Web Application Resources

Including Requests

Forwarding Requests

Destroying Servlet Instances

Developing Event Listeners

Developing Filters

Developing JSP Pages

Creating JSP Files in the Developer Studio

JSP Life Cycle

Syntax Elements Outline

Using the page Directive

Implicit Objects

Standard Actions

Including and Forwarding Requests in a JSP

JSTL

Developing Custom Tags

Developing Classic Tag Handlers

Developing Simple Tag Handlers

Developing TLD Files

Describing Tag Handlers in TLD Files

Developing Tag Files

Describing Tag Files in TLD Files

Unified Expression Language

EL Expressions in Tag Attribute Values

Deferred Expressions Evaluation

Using EL Implicit Objects

Developing EL Functions

Developing Portlets

Packaging and Deployment Descriptor

Using CC/PP with Portlets

Customizing Default Error Pages

Defining Custom HTTP Response Status Codes

Editing the web-j2ee-engine.xml

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

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

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

Creating 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

Choosing a Service Endpoint Interface Options

Customizing Web Service Endpoint

Providing Web Services Outside In

Importing WSDL Documents in the SAP NetWeaver Developer Studio

Importing a WSDL Document from Enterprise Services Repository

Importing a WSDL Document from a Remote Location or File System

Importing a WSDL Document from Services Registry

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 Services in Search Console

Configuring Connections to Solution Composer Systems

Searching for Enterprise Services in Solution Composer

Searching for RFC Function Modules

Searching for Web Services in the Local Workspace

Importing Enterprise Services in the Workspace

Importing RFC Function Modules in the Workspace

Adding Service Interfaces and Operations to Search Favorites

Browsing Service Endpoints

Providing a TU&C/C Web Service

Processing Large Data by Web Services

Configuring Web Services at Design Time

Setting an Authentication Level

Setting the Transport Guarantee Level

Configuring a One Way Message Exchange Pattern

Configuring Web Services Reliable Messaging

Configuring URLs for Web Service Endpoints

Configuring Stateful Communication

Connecting the SAP NetWeaver Developer Studio to the Services Re

Configuring Resource Management Settings

Adding Classifications to Web Services

Viewing Web Service Artifacts

Editing the Properties of Web Service Artifacts

Restrictions to Web Service Implementation Beans

Creating Design Objects using SAP NetWeaver Developer Studio

Consuming Web Services

Creating Web Service Proxies

Creating Clients for Locally Provided Services

Creating Service Groups

Creating Shared Service Groups

Creating Private Service Groups

Creating Predefined Service Groups

Creating Classified Service Groups

Editing Service Groups and Service References

Creating Web Service Client Applications

Consuming TU&C/C Web Services

Consuming Idempotent Web Services

Extended Proxy Capabilities

Importing Applications Created with Previous Releases of SAP Net

Supported Specifications

Tutorials

Developing a HelloWorld Web Service

Creating the HelloWorld Web Service

Creating an Enterprise Java Bean Project for the HelloWorld Web

Creating the Enterprise Java Bean

Exposing the Enterprise Java Bean as a Web Service

Deploying the HelloWorld Web Service

Testing the HelloWorld Web Service

Creating the HelloWorld Web Service Client

Creating a Dynamic Web Project for the Web Service Client

Importing the WSDL Document

Generating the Web Service Proxy

Creating the Web Service Client Application

Deploying the HelloWorld Web Service Client

Exposing and Configuring the Converter Application as a Web Serv

Exposing the Converter Application as a Web Service

Importing the Converter Application in the SAP NetWeaver Develop

Exposing the Implementation EJB as a Web Service

Setting an Authentication Level to the Web Service

Deploying the Converter Web Service

Configuring the Web Service in the SAP NetWeaver Administrator

Testing the Converter Web Service

Creating the Converter Web Service Client

Creating a Dynamic Web Module for the Converter Consumer Applica

Importing the Converter WSDL Document

Generating the Converter Web Service Proxy

Generating the Converter Service Group

Creating the Converter Web Service Client Application

Deploying the Converter Web Service Client

Configuring the Web Service Client in the SAP NetWeaver Administ

Setting Severity to Web Services and Web Service Clients

Starting the Converter Web Service Client Application

Viewing Converter Web Service and Web Service Client Logs and Tr

Using Java Message Service

JMS Overview

JMS Clustering and Failover

JMS Connector Concept and Related Tasks

Creating and Configuring JMS Virtual Providers

Creating and Configuring JMS Resources and Resource References

Property Reference

Accessing JMS Resources

Using JMS Resources from Two and More Applications

Creating Message Producers and Consumers

Using Queue Browsers

Using Durable Subscriptions

Using Message Selectors

Message Selector Syntax

Consuming Messages from Message-Driven Beans

Processing Messages

Handling Dead Messages

Defining Security in JMS

Using Transactions

Configuring Transaction-Related JMS Connection Factory Propertie

Using JMS XA Transactions

Using Third-Party JMS Providers

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

Specific Class Loading Use Cases

Assembling Components into Enterprise Applications

Creating Enterprise Application Projects

Adding Modules to the Enterprise Application

Adding the application.xml to Enterprise Application Projects

Editing the application-j2ee-engine.xml

Referencing Non-Existent Bundled Libraries

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

Deploying Applications

Security Actions Necessary to Perform Deploy Operations

Deploying and Undeploying with SAP NetWeaver Developer Studio

Building, Publishing and Removing Published Java EE Applications

Deploying Archives

Working with Deploy Templates

Managing Deployed Archives

Undeploying Archives

Managing Substitution Variables

Viewing Deployment Related Logs

Filtering and Sorting Archives

Deploying Applications with Third-Party Deployment Tools

Using Ant Scripts to Work with SDAs

Using Shell Scripts to Work with SDAs

Managing the Application Environment

Creating Your Own Application Tables in the Database

demotables.sql

Working with DataSources

Deploying DataSources

Deploying DataSource Aliases

Deploying JDBC Drivers

Creating J2EE 1.4 Applications in SAP NetWeaver Developer Studio

Creating J2EE 1.4-Compliant Web Components

Creating EJB 2.1 Components

Assembling J2EE 1.4-Compliant Enterprise Applications

Debugging Java EE Applications

Configuring AS Java for Debugging

Creating Debug Configurations in the Developer Studio

Stopping Remote Debugging

Creating Platform-Independent Java EE Applications

Migrating Existing Java EE Applications to AS Java

Using AS Java APIs

Using JavaMail

Configuring the JavaMail Client Service

Obtaining a Session Object

Creating E-Mail Messages

Sending E-Mail Messages

Receiving E-Mail Messages

Creating Secure Connections Using JavaMail

HTTP Client

HTTP Client Properties

Simple Get Request to a Specified Host and Port

Get Request Using Proxy

Posting File Using Chunked Encoding

Get Request Using Basic Authentication

Managing System and Application Configurations

Configuration Manager

Monitoring Configurations

Java Configuration Browser

Adding Configuration Capabilities to an Application

Connecting As an AS Java Application

Deploying Properties Within an Application

Accessing Application Properties

Registering a Property Change Listener

Modifying Application Properties

Accessing the System Profile

Naming and Directory Services (JNDI)

JNDI Registry Service

Creating an Initial Context

Binding Objects

Looking up Objects

Browsing the Naming Tree

JNDI Browser

NAMING Shell Commands

Using JNDI Registry Service to Locate Resources

RMI-P4 Overview

Developing Distributed Applications Based on RMI-P4

Defining a Remote Interface

Implementing the Remote Interface

Binding the Implementation to the Naming System

Implementing a Client

Accessing Enterprise JavaBeans from Remote Clients

RMI-P4 Reference

Using P4 Protocol Over a Secure Connection

Network Configuration for RMI-P4

Advanced P4 Protocol Connection Configuration

RMI-P4 Specific InitialContext Properties

HTTP Tunneling Specific Configuration

Reference

Deployment Descriptors

appclient-j2ee-engine.xsd

application-j2ee-engine.xsd

application-service.dtd

connector-j2ee-engine.xsd

ejb-j2ee-engine.xsd

ejb-j2ee-engine_3_0.xsd

data-source-aliases.dtd

Tutorials

Project Management and Employee Services Application

Running the Application

Setting Up Application Users

Application Users and User Groups

Deploying and Starting the Application

Running the Application Scenario

Application Data Model

Developing a Message-Driven Bean Application

Creating an EJB 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 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