Using Java |
Getting Involved |
Concepts of the Developer Studio |
Eclipse as an Integration Platform |
SAP Toolsets and Perspectives |
The Web Dynpro Toolset |
Working with J2EE Tools |
The Web Services IDE |
Persistence Tools |
The SAP Enterprise Connector |
Testing Java Applications |
SAP Perspectives |
Development Configurations Perspective |
Web Dynpro Perspective |
J2EE Development Perspective |
Web Service Perspective |
Dictionary Perspective |
Design Time Repository Perspective |
SAP Development Infrastructure for Java |
Working with the Developer Studio |
Starting the Developer Studio |
Starting the Developer Studio Using a Batch File |
Setting Workspace Using the data Parameter |
Changing the Default Workspace |
Setting the Java VM Using the - vm Parameter |
Using Other Start Parameters |
Working with J2EE Tools |
Basic Functions |
Creating EJB Projects |
Creating Stateful Session Beans |
Creating Stateless Session Beans |
Creating Entity Beans |
Creating Message-Driven Beans |
Editing Enterprise Beans |
Creating and Editing the Enterprise Beans' Methods |
Creating the Bean's Persistent Fields |
Creating Beans' Relationships |
Propagating Methods to the Remote and Local Interfaces |
Building EJB JARs |
Creating Web Projects |
Creating JSP Files |
Creating Servlets |
Creating Filters |
Creating Listeners |
JSP Editor |
HTML Editor |
Building WARs |
Creating Enterprise Projects |
Adding Modules to Enterprise Projects |
Building EARs |
Specifying Additional Libraries to be Packed into EAR Files |
Deploying EARs |
Creating Data Source Aliases |
Creating Packages |
Configuring the J2EE Tools |
Editors for Deployment Descriptors |
EAR Configuration |
Editing application.xml |
Specifying Application Display Information |
Specifying Alternative URIs |
Specifying the Context Root |
Adding and Removing Security Roles |
Editing application-j2ee-engine.xml |
Editing Application References |
Enabling and Disabling HTTP Failover |
Specifying the Additional Classpath |
Specifying the Application Startup Mode |
Adding and Removing Additional Modules |
WAR Configuration |
Editing web.xml |
Editing web-j2ee-engine.xml |
JAR Configuration |
Editing ejb-jar.xml |
Editing ejb-j2ee-engine.xml |
Editing persistent.xml |
Working with J2EE Engine Libraries |
Defining Libraries |
Creating a Library Project |
Adding JARs and References |
Creating a Library Archive |
Deploying a Library Archive |
Defining Library DCs |
Creating a Library DC |
Declaring the Use of Other DCs |
Executing the Component Build |
Referencing Libraries in Applications |
Declaring Explicit References to Libraries |
Declaring Implicit References to Libraries |
Importing J2EE Sources |
Importing J2EE Projects in the SAP NetWeaver Developer Studio |
SAP Web AS 6.20 and the SAP NetWeaver Developer Studio |
Migrating from Web AS 6.20 |
Assembling Enterprise Beans from Existing Classes |
Propagating Metadata from ejb-jar.xml to Sources |
Diagram View |
Creating Packages in the Diagram View |
Editing EJB Projects in the Diagram View |
Creating Enterprise Beans in the Diagram View |
Creating EJB Relationships in the Diagram View |
Editing ejb-jar.xml in the Diagram View |
Editing Web Projects in the Diagram View |
Creating Folders in the Diagram View |
Creating JSP and HTML Pages in the Diagram View |
Importing Resources in the Diagram View |
Editing web.xml in the Diagram View |
Editing Enterprise Projects in the Diagram View |
Web Dynpro Tools |
Controller/Context Editor |
Context Structure |
Model Binding |
Providing Data Using Value Nodes and Value Attributes |
Data Modeler |
Creating a Data Link |
View Templates |
Using the Form Template |
Using the Table Template |
Using the ActionButton Template |
Using the Service Controller |
Using the Relate Context Attribute Template |
Message Editor |
Creating a User Message |
Navigation Modeler |
Creating a View |
Creating a View Set |
Embedding a View in a View Set |
Creating a Plug |
Creating a Link |
View Designer |
Working with User Interface Elements |
The User Interface Element Container |
Chart Designer |
Calling the Chart Designer |
Web Dynpro Explorer |
Creating a Project |
Creating a Web Dynpro Development Component Project |
Web Dynpro Class File Minimizer |
Importing a Project |
Deleting a Project |
Navigator |
Web Dynpro Model Tools |
Importing an Adaptive RFC Model |
Adaptive RFC |
Reusing BAPI Data |
Multiple Back End Support for the Adaptive RFC Model |
Importing a Web Service Model |
Importing a JavaBean Model |
Using External Data Imported from an XMI Model |
Conditions for an XMI Model Import |
Referencing a Model |
Java Dictionary |
Modifying Dictionary Preferences |
Development Process |
Creating Data Types |
Initial Values |
Creating Structures |
Reference Fields |
Tables |
Creating Tables |
Buffering Type |
Creating Indexes |
Deploying Tables |
Editing Table Definitions |
Web Service Toolset |
Web Service Perspective |
Creating a Web Service |
The Development Process |
Creating a Web Service for an Enterprise JavaBean |
Web Service Creation Wizard |
Creating a Virtual Interface |
Creating a Web Service Definition |
Creating a Web Service and a Web Service Configuration |
Creating a Web Service for a Java Class |
Exposing Portal Services as Web Services |
Web Service Navigator |
Advanced Techniques |
Creating a Web Service with Attachments |
Maintaining SOAP Extensions |
Consuming a Web Service |
Creating a Deployable Proxy |
Creating a Client Bean |
Creating a Client Servlet |
Creating a Client JavaServer Page |
Creating a Standalone Proxy |
Configuring Logical Ports |
Extended Proxy Capabilities |
Web Service Administration Using the Visual Administrator |
Web Service Homepage |
Web Services Security |
Secure Transmission |
WS Security |
Authentication |
Configuring Transport Authentication |
Configuring Document Authentication |
Authorization |
Testing Java Applications |
JLin |
Creating and Editing Variants |
Executing Tests |
Results |
Testing Web Dynpro Applications in the Developer Studio |
Test Scripts and Test Results |
Recording a Test Script in the Developer Studio |
Replaying a Test Script in the Developer Studio |
Comparing Scripts and Results |
Go and Create |
Creating Your First Web Dynpro Application |
Creating a Web Dynpro Project |
Creating a Web Dynpro Component |
Creating further Views |
Specifying the Navigation Schema |
Creating Actions and Implementing Navigation |
Designing a View Layout |
Defining Data Binding for UI Elements |
Creating a Web Dynpro Application |
Building, Deploying, and Running Your Application |
Creating Your First J2EE Application |
Creating an EJB Module Project |
Developing the Calculator Session Bean |
Creating the Enterprise Bean Archive |
Creating a Web Module Project |
Developing the JavaBean CalcProxy |
Developing the Calculator.jsp |
Building the Web Archive |
Assembling the Calculator Application |
Deploying and Running the Calculator Application |
Creating a J2EE-Based Car Rental Application |
Defining a Data Model |
Creating a Dictionary Project |
Creating a Table |
Adding Table Columns |
Creating an SDA |
Deploying an SDA |
Implementing Data Access |
Creating an EJB Module Project |
Creating the QuickBookingBean Entity Bean |
Adding the Implementation of the ejbCreate Method |
Implementing the Business Logic |
Creating and Implementing Auxiliary Classes |
Creating a Java Project as a Source Container |
The Constants Class |
The QuickBookingModel JavaBean |
The Exception Class QuickCarRentalException |
Exporting the JAR File |
Creating the Session Bean QuickOrderProcessorBean |
Implementing the Session Bean Class |
Throwing the Exception QuickCarRentalException |
Implementing the saveBooking() Method |
Implementing the cancelBooking() Method |
Implementing the viewActiveBookings() Method |
Creating a JAR |
Editing Deployment Descriptors |
Adding Descriptions to ejb-jar.xml |
Adding Descriptions to persistent.xml |
Adding Descriptions to ejb-j2ee-engine.xml |
Creating a Jar File |
Implementing a Web Application |
Creating a Web Module Project |
Creating the JSP quickCarRentalView |
Adding Source Code |
Creating the QuickReservationServlet Servlet |
Adding Source Code to the Servlet |
Creating a Web Archive |
Editing Deployment Descriptors |
Adding Descriptions to web.xml |
Creating a War File |
Creating and Deploying the Complete J2EE Application |
Creating an Enterprise Application Project |
Editing Deployment Descriptors |
Adding Descriptions to application.xml |
Creating a DataSource Alias |
Creating an Ear File |
Deploying an EAR |
Executing the Car Rental Application |
Making the Car Rental Application Available as a Web Service |
Creating a Web Service |
Deploying the Web Service QuickCarRentalService |
Creating a Web Dynpro Application Accessing ABAP Functions |
Importing a Project Template |
Developing the Example Application Steps |
Creating a Model |
Creating a Custom Controller Context and Binding it to the Model |
Mapping Custom Context Elements to View Context Elements |
Creating Actions and Declaring Methods |
Editing the UI Elements |
Adding the Implementation of the Backend Connection |
Building, Deploying, Configuring, and Running Your Application |
Using the Car Rental Web Service with Web Dynpro |
Importing a Project Template |
Creating a Model |
Creating a Component Context and Binding It to the Model |
Mapping a View Context onto the Component Controller |
Defining Data Binding for UI Elements |
Implementing the Event Handler of the View |
Building, Deploying, and Running Your Application |
Creating an Email Client Using Web Dynpro and Web Services |
Creating a Project Structure |
Creating a Web Service Model |
Creating the Binding: Component Controller Context and Model |
Mapping View Context Elements to Component Context Elements |
Creating the SendEmail Action |
Designing a View Layout |
Adding the Implementation for the Web Service Connection |
Calling the Execute Method |
Building, Deploying, and Running the Project |
Debugging J2EE Applications |
Activating Debugging |
Preparations for Debugging a JSP |
Debugging a JSP |
Preparations for Debugging a Servlet |
Debugging a Servlet |
Debugging a Web Dynpro Application |
Activating Debugging |
Starting a Debug Session |
How to Perform Development with a Track |
Setting Up the Development Environment |
Creating Users and Assigning Groups Using UME |
Managing the Track |
Creating a Software Component in the SLD |
Registering the Reserved Prefix for the Name Reservation Service |
Creating a Domain |
Creating a Track |
Checking In and Importing Required SCs |
Developing the Software |
Importing the Development Configuration |
Developing a Java Development Component |
Creating a Development Component |
Developing the Project |
Building the Development Component Locally |
Creating Public Parts for the Development Components |
Checking in the Activity |
Developing a Library Development Component |
Creating a Development Component |
Declaring the Use of Another Development Component |
Building and Deploying the Library |
Checking in to the DTR |
Creating a J2EE Application |
Creating Development Components |
Creating a JSP |
Creating a Java Class |
Creating Use Dependencies on Another Development Component |
Creating a Reference |
Testing and Checking In a DC |
Activation in the CBS |
Building the Software |
Releasing the Changes for Consolidation |
Consolidate Changes |
Creating an SCA File |
Importing SCA into the Test System |
Transporting the Software |
Starting and Stopping the SAP System |
Core Development Tasks |
Developing User Interfaces |
Web Dynpro for Java |
Getting Involved |
Architecture of Web Dynpro |
Web Dynpro Component |
View |
View Set |
Plugs and Navigation Links |
Web Dynpro Window |
Window Plugs |
Controller |
Context |
Context Nodes: Properties |
Data Binding and Mapping |
Event |
Action |
Interfaces of Web Dynpro Components |
Web Dynpro Application |
Web Dynpro Model |
Concepts of Web Dynpro for Java |
The Model View Controller Paradigm |
The Component Concept |
The Web Dynpro Project in the NWDI |
Development in a Team |
Importing Development Configurations |
Creating a New Web Dynpro DC |
Providing Functions for Other DCs |
Creating a Public Part for a DC |
Including Development Objects in a Public Part |
Using Functions of Other DCs |
Defining Usage Dependency for a DC |
Example: Using a Foreign Web Dynpro Component |
Developing Locally |
Creating a New Web Dynpro Project |
Migrating Local Web Dynpro Projects |
Some Rules for Working with the DTR |
Naming Conventions |
Naming Convention for Abbreviations |
Naming Conventions for Coding Entities |
Go and Create |
Creating the First Application Elements |
Creating a Project |
Creating a Web Dynpro Development Component Project |
Creating a Component |
Copying a Component |
Embedding Components |
Nesting Components |
Specifying the Call Sequence of Components |
Referencing a Component |
Creating a Window |
Creating a View |
Copying a View |
Creating an Application |
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 an Extended Web Dynpro Application |
Quiz Application |
Creating the First Parts of the Application |
View Modeling and User Interface Layout |
Determining the Content and Interaction of Views |
Defining a View Composition |
Implementing the View Composition |
Designing a View Layout |
Using the ActionButton Template |
Creating Navigation Transitions |
Controller Contexts and Data Binding |
Defining Controller Contexts |
Defining Data Binding |
Context Programming |
Adding QuizData Node Elements in Context Nodes |
Initializing Top Level Value Attributes |
Programming Context State Changes |
Portal Integration of the Web Dynpro Application |
Core Development Tasks |
Model and Java Dictionary |
Importing an Adaptive RFC Model |
Adaptive RFC |
Reusing BAPI Data |
Multiple Back End Support for the Adaptive RFC Model |
Mapping Logical Systems |
Security of Logical Systems |
Importing a Web Service Model |
Importing a JavaBean Model |
Importing a WD Model of the Type JavaBean for a Local WD Project |
JavaBean Model in a Development Component Project |
Conditions and Naming Conventions for an Import Bean |
Using External Data Imported from an XMI Model |
Conditions for an XMI Model Import |
Editing Model Classes |
Referencing a Model |
Defining Dictionary Data Types and Structures |
Defining Currencies |
View Programming UI and Navigation |
View Structure and Design |
Creating a View |
Creating a View Set |
Embedding a View in a View Set |
Copying a View |
Renaming a View |
ViewContainerUIElement API |
View Templates |
Using the ActionButton Template |
Using the Form Template |
Using the Table Template |
Navigation, Plugs and Navigation Links |
Creating a Plug |
Creating a Link |
Implementing Methods for Outbound Plug Calls |
Suspend and Resume Plug |
Using the Suspend and Resume Plugs |
UI Elements, Data Binding and Event Handling |
UI Element Guide |
Common UI Element Properties |
Methods of the UI Element APIs |
Layout |
MatrixLayout API |
MatrixData API |
MatrixHeadData API |
GridLayout API |
GridData API |
RowLayout API |
RowData API |
RowHeadData API |
FlowLayout API |
FlowData API |
Containers |
ScrollContainer API |
Group API |
TransparentContainer API |
Tray API |
BIApplicationFrame API: Integrating BEx Web Applications |
BIMethods API: Access to Actions of a BEx Web Application |
Breadcrumb Navigation |
BreadCrumb API |
BreadCrumbStep API |
MultipleBreadCrumbStep API |
BusinessGraphics API |
UML Model of the Business Graphics |
Category API |
Series API |
Point API |
SimpleSeries API |
NumericValue API |
TimeValue API |
Data Binding of a BusinessGraphics UI Element |
Button - ButtonRow |
Caption API |
CheckBox API |
CheckBoxGroup API |
DateNavigator |
DateNavigator API |
DateNavigatorMarking API |
DateNavigatorLegend API |
DropDownByIndex API |
Data Binding for DropDownByIndex Elements |
DropDownByKey API |
Data Binding for DropDownByKey Element |
FileUpload and FileDownload: Data Transfer |
FileUpload API |
FileDownload API |
Data Binding for resource Property with FileDownload and FileUpl |
Loading the InputStream at FileDownload on Demand |
Gantt API |
HorizontalGutter API |
GeoMap API |
Code Example of the Use of a Geographical Map |
Example for Displaying a Route |
IFrame API |
Image API |
InputField API |
ItemListBox API |
Label API |
Legend API |
LegendItem API |
MultipleLegendItem API |
LinkToAction API |
LinkToURL API |
MenuBar and Popup Menu |
MenuBar API |
Menu API |
MenuActionItem API |
MenuCheckBox API |
MenuRadioButton API |
Network API |
OfficeControl API |
Using OfficeControl |
Pattern UI Elements |
PageHeader |
PageHeaderArea |
ContextualPanel |
ViewSwitch |
FreeContextualArea |
NavigationList |
ExpandableTitle |
PatternTabStrip |
PatternTab |
PatternTray |
PatternContentArea |
PatternExpandFunction |
MessageArea |
PhaseIndicator |
Web Dynpro PhaseIndicator API IWDPhaseIndicator |
Phase API |
ProgressIndicator API |
RadioButton API |
RadioButtonGroupByKey API |
RadioButtonGroupByIndex API |
RoadMap API |
RoadMapStep API |
MultipleRoadMapStep API |
Table |
Table API |
Filtering and Sorting in a Table |
TableColumnGroup API |
TableColumn API |
TreeByNestingTableColumn API |
Cell Variants |
TableStandardCell API |
TableSingleMarkableCell API |
Defining Cell Variants |
TablePopin API |
TablePopinToggleCell API |
TextBar API |
Tabstrip |
TabStrip API |
Tab API |
TextEdit API |
TextView API |
TimedTrigger API |
ToggleButton API |
ToggleLink API |
Toolbar |
ToolBar API |
ToolBarButton API |
ToolBarButtonChoice API |
ToolBarDropDownByIndex API |
ToolBarDropDownByKey API |
ToolBarInputField API |
ToolBarLinkToAction API |
ToolBarLinkToURL API |
ToolBarSeparator API |
ToolBarToggleButton API |
Tree API |
TreeNodeType API |
Web Dynpro TreeItemType API - IWDTreeItemType |
Data Binding of a Tree UI Element |
Code Example for Creation of a Tree UI Element |
TriStateCheckBox API |
ValueComparison API |
Data Binding of User Interface Element Properties |
Bindable Data Types |
Typing Context Attributes for Data Binding |
Assignment of Dictionary Types and Java Types |
Dynamic Metadata |
Code Examples of Data Binding |
Code Example of Key Binding |
Data Binding of a Dropdown List Box and Radio Button Group |
Code Example of the Use of a Recursive Node |
Dynamic UI Generation |
Dynamic Generation of a User Interface Element |
Event Handling |
UI Element Event Model |
Generic Validation Service |
Web Dynpro Action at Runtime Interface IWDAction |
Creating an Action at Design Time |
Action Types |
Non-Validating and Validating Actions |
Event Parameter and Parameter Mapping |
Web Dynpro ParameterMapping API - IWDParameterMapping |
Programming User Messages |
Error Handling |
Creating a User Message |
Messages |
Processing a Message |
Example for Using Messages |
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 |
Development of Interactive Adobe Forms for the Web Dynpro UI |
Adobe Library |
InteractiveForm API |
Web Dynpro Form UI Element CheckFields |
Web Dynpro Form UI Element EnumeratedDropDownList |
Web Dynpro Form UI Element EnumeratedDropDownListNoSelect |
Web Dynpro Form UI Element HideReaderToolbar |
Web Dynpro Form UI Element SubmitToSAP |
Web Dynpro Form UI Element ValueHelpDropDownList |
Example of the Use of an Interactive PDF Form |
Configuring the Destination URL for the Adobe Document Services |
Controller and Context |
Controllers |
Component Controller |
Interface Controllers |
Custom Controllers |
Creating a Custom Controller |
Editing a Custom Controller |
Copying a Custom Controller |
Referencing a Custom Controller |
Renaming a Custom Controller |
Using the Service Controller |
View Controllers |
Web Dynpro Phase Model |
Context Description |
Declaration of Controller Contexts |
Context Structure |
Nodes and Node Elements |
Independent and Dependent Nodes |
Node Collection |
Lead Selection and Node Selection |
Structure Nodes and Structure Binding |
Singleton and Non-Singleton Nodes |
Supply Functions |
Recursive Context Nodes |
Context Attributes |
Typing Context Attributes for Data Binding |
Assignment of Dictionary Types and Java Types |
Calculated Context Attribute |
Using the Relate Context Attribute Template |
Context Mapping |
Mapping Independent and Dependent Nodes |
Mapping Context Attributes |
Creating a Data Link |
External Context Mapping |
Mapping Recursive Context Nodes |
Model Binding |
Web Dynpro Application: Configuration, Deployment and Execution |
Configuring a Web Dynpro Application |
Setting Values of the Application Properties |
Configuring the Web Dynpro Runtime Environment |
Using LogoffURL for Redirection After Terminating the Applicatio |
Configuration Service |
User Management Service |
Deploying and Executing a Web Dynpro Application |
Deployment Service |
Executing a Web Dynpro Application: Clients |
Web Dynpro-Specific URL Parameters |
URL Generation Service |
Configuring the Destination URL for the Adobe Document Services |
Portal Integration of Web Dynpro Applications |
Personalization |
Mobile Web Dynpro Online |
Specifics of Nokia Series 80 and 60 Devices |
Specifics of BlackBerry Wireless Handhelds |
Specifics of Pocket PCs |
Mobile Add-On Library |
BarCodeReader API |
Using the BarCodeReader |
FunctionKey API |
Using the FunctionKey |
RFIDReader |
Using the RFIDReader |
Ensuring Quality |
Debugging a Web Dynpro Application |
Enabling Debugging on the Server |
Setting Breakpoints in Web Dynpro Applications |
Creating Debug Launch Configurations |
Starting and Stopping Debugging |
Logging, Tracing and Monitoring |
Client Tracing |
Logging |
Availability Monitoring for Web Dynpro Applications |
Web Dynpro Console |
Performance Data Within the Request Response Cycle |
Measuring the Performance of the Web Dynpro Framework |
Determination of Performance Data for Clients |
Display of Performance Data for Requests |
Display of Performance Data for the Model or Backend |
Display of Performance Data for Users |
Invalidating Metadata Caches |
Metadata Comparison for Web Dynpro Projects |
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 |
Services for the SAP System Landscape Directory and SAP Java Con |
References |
Web Dynpro Tools |
Controller/Context Editor |
Context Structure |
Model Binding |
Providing Data Using Value Nodes and Value Attributes |
Data Modeler |
Creating a Data Link |
View Templates |
Using the Form Template |
Using the Table Template |
Using the ActionButton Template |
Using the Service Controller |
Using the Relate Context Attribute Template |
Message Editor |
Creating a User Message |
Navigation Modeler |
Creating a View |
Creating a View Set |
Embedding a View in a View Set |
Creating a Plug |
Creating a Link |
View Designer |
Working with User Interface Elements |
The User Interface Element Container |
Chart Designer |
Calling the Chart Designer |
Web Dynpro Explorer |
Creating a Project |
Creating a Web Dynpro Development Component Project |
Web Dynpro Class File Minimizer |
Importing a Project |
Deleting a Project |
Navigator |
Web Dynpro Model Tools |
Importing an Adaptive RFC Model |
Adaptive RFC |
Reusing BAPI Data |
Multiple Back End Support for the Adaptive RFC Model |
Importing a Web Service Model |
Importing a JavaBean Model |
Using External Data Imported from an XMI Model |
Conditions for an XMI Model Import |
Referencing a Model |
J2EE Web Applications |
J2EE Application Concepts |
Web Container |
J2EE Web Application |
Web Components |
Servlet Life-cycle |
JSP Life-cycle |
Objects of Scope |
Hints on Designing J2EE Web Applications |
Developing J2EE Web Applications |
Creating Web Projects |
Developing Servlets |
Creating Servlets |
Initializing Servlets |
Servicing Client Requests |
Retrieving Client Input |
Retrieving Multipart Request Messages |
Request Attributes When Using Application Zones |
Obtaining the Remote Host Address |
Composing HTTP Responses |
HTTP Response over Persistent Connections |
IOException in Cases When Client Closes Connection |
Threadsafe Servlets |
Handling Cookies in Servlets |
Setting Cookies in HTTP Servlets |
Retrieving Cookies from the HTTP Request |
J2EE Engine Cookies |
Servlet-defined Cookies |
HTTP Sessions |
Lifetime of a Session |
Session Tracking with Servlets |
Accessing and Manipulating the Session Object |
Terminating a Session |
URL Rewriting as an Alternative to Cookies |
HTTP Sessions and Failover of Web Applications |
Session Support for Concurrent Requests |
Dispatching Requests to Web Application Resources |
Including Requests |
Forwarding Requests |
Destroying Servlet Instances |
Developing Event Listeners |
Developing JSP Pages |
Creating JSP Files |
JSP Syntax Elements Outline |
Implicit Variables |
Using the page Directive |
Using the taglib and include Directives |
Including and Forwarding Requests in a JSP |
Using Declarations |
Using Scriptlets |
Developing Custom JSP Tag Libraries |
Implementing Tag Handlers |
Describing the Tag Library |
Using a Custom Tag in a JSP Page |
Developing Filters |
Initializing Filters |
Filtering Requests or Responses |
J2EE Web Applications Security |
Authentication for Web Applications Users on the J2EE Engine |
Overview of the Login Process in JAAS |
Using Login Modules to Protect Web Applications |
SAP Specific HTTP Callbacks |
Changing the User Password |
Security Sessions |
Authorization for Web Application Users on the J2EE Engine |
Single Sign-on for J2EE Web Applications |
Propagation of Security Principals to Other Containers on the J2 |
Building WARs |
J2EE Web Components Configuration |
Specifying Web Application Display Information |
Declaring and Configuring Web Components |
Defining Servlet Context Parameters |
Mapping Servlets and JSP Pages |
Mapping Filters |
Setting up the Application Operational Environment |
Configuring Environment Entries |
Configuring Resource Environment Entries |
Configuring Resource References |
Configuring Enterprise Bean References |
Defining Server Component References |
Configuring Web Applications Security |
Specifying Security Constraints |
Defining Web Application Security Roles |
Configuring Authentication |
Configuring the J2EE Engine Cookies |
Limiting the Number of HTTP Sessions |
Custom Error Pages |
Configuring Custom Error Response Pages |
Defining Custom HTTP Response Status Codes |
Configuring JSP Tag Libraries |
Configuring Failover Alert |
Configuring Welcome Pages |
Configuring Session Tracking with URL Rewriting Only |
Specifying HTTP Session Timeout |
Default Configurations of the Web Container |
Editing the Global Deployment Descriptors |
Default Implementation of HTTP PUT Method |
Providing Long-lived Request and Response Objects |
JSP Servlet |
Invoker Servlet |
Default Servlet |
PasswordChangeForm Servlet |
Creating Enterprise Projects |
Building EARs |
Deploying EARs |
Metadata Comparison Tool |
Developing Business Logic |
Developing Enterprise Beans |
Introduction to Enterprise Beans |
Enterprise Bean Structure |
J2EE Engine EJB Architecture |
Developing an EJB Application |
Creating EJB Projects |
Developing Session Beans |
Stateful or Stateless Session Beans |
Creating Stateless Session Beans |
Creating Stateful Session Beans |
Creating and Editing the Enterprise Beans' Methods |
Creating and Editing the Deployment Descriptors |
Setting the EJB JAR Properties |
Specifying Bean-Specific Properties |
Declaring Environment Entries |
Declaring EJB References |
Declaring Resource References |
Defining Transaction Attributes |
Specifying Arbitrary JNDI Names for Your Beans |
Specifying the Beans Container Size |
Specifying JNDI Names for the Beans References |
Specifying References to Objects Bound in the JNDI |
Stateful Session Beans' Timeouts |
Specifying Stateful Session Beans' Timeouts |
Developing Entity Beans |
Bean-Managed or Container-Managed Entity Beans |
Creating Entity Beans |
Creating and Editing the Enterprise Beans' Methods |
Creating the Bean's Persistent Fields |
Creating Primary Keys |
Creating Dependent-Value Persistent Fields |
Container-Managed Relationships |
Creating Beans' Relationships |
Defining Relationships Between Container-Managed Entity Beans |
Mapping Relationships |
Creating and Editing the Deployment Descriptors |
Setting the EJB JAR Properties |
Specifying Bean-Specific Properties |
Declaring Environment Entries |
Declaring EJB References |
Declaring Resource References |
Specifying the Deployment Properties of Finder/Select Queries |
Defining Transaction Attributes |
Specifying Arbitrary JNDI Names for Your Beans |
Specifying the Beans Container Size |
Specifying the Initial Cache Size of the Persistence Manager |
Specifying Primary Key Deployment Properties |
Specifying JNDI Names for the Beans References |
Specifying the Data Source and the Database Vendor |
Specifying References to Objects Bound in the JNDI |
Locking |
Choosing the Type of Enqueue Server Locking |
Isolation Levels |
Enabling Database Locking |
Database Mapping |
Mapping Entity Beans to Database Tables |
Mapping Persistent Fields (cmp-fields) |
Mapping Relationships |
Verifying the Object/Relational Mapping |
Object/Relational Mapping Rules |
Optimizations and Performance Tuning |
Defining Entity Beans as Read-Only |
Developing Message-Driven Beans |
Creating Message-Driven Beans |
Creating and Editing the Deployment Descriptors |
Setting the EJB JAR Properties |
Specifying Bean-Specific Properties |
Declaring Environment Entries |
Declaring EJB References |
Declaring Resource References |
Defining Transaction Attributes |
Specifying Arbitrary JNDI Names for Your Beans |
Specifying JNDI Names for the Beans References |
Configuring Message-Driven Bean Specific Properties |
Specifying References to Objects Bound in the JNDI |
Message-Driven Bean Example |
Pool Properties |
Specifying the Pool Properties |
Security for Enterprise Beans |
Defining Security Roles |
Mapping Security Roles |
Specifying Permissions for Method Invocations |
Declaring Security Role References |
Specifying Security Identity |
Specifying Security When Using IIOP |
Failover for Enterprise Beans |
Enabling and Disabling HTTP Failover |
Enabling Stateful Session Failover |
Specifying the Failover Persistent Storage |
Enterprise Bean Clients |
Looking Up Enterprise Beans |
Connecting to Enterprise Beans on SAP NetWeaver 7.2 AS Java |
Building EJB JARs |
Creating Enterprise Projects |
Building EARs |
Deploying EARs |
Configuring Enterprise Beans After Deployment |
Java Messaging |
Developing JMS Applications |
JMS Overview |
Destinations |
Point-to-Point Model |
Creating a Message Producer and Consumer for a Queue |
Queue Sender and Receiver |
Limitation of Message Delivery Attempts |
Publish-Subscribe Model |
Creating a Message Producer and Consumer for a Topic |
Topic Publisher Example |
Asynchronously Receiving Messages Sent to a Topic |
Synchronously Receiving Messages Sent to a Topic |
Managing Durable Subscriptions |
Creating Temporary Destinations |
Message Selector |
Creating a Message Selector |
Message Selector Syntax |
JMS Messages |
Processing the Received Messages |
Message Acknowledgement |
JMS Provider Security Aspects |
Closing Connections and Handling Exceptions |
Getting Started with Message-Driven Bean Development |
Using Message Driven Beans in SAP NetWeaver Application Server |
Setting Up the JMS Environment Using the Visual Administrator |
Defining the Connection Factory and Destination Wrapper Objects |
Deploying the Connection Factories and Destinations |
JMS Client Example |
The Message Driven Bean |
Creating the MDB Application |
Creating an EJB Module Project |
Developing the Message Driven Bean |
Creating the Enterprise Bean Archive |
Assembling the MDB Application |
Deploying the MDB |
Running the Example |
Developing Message-Driven Beans |
Creating Message-Driven Beans |
Creating and Editing the Deployment Descriptors |
Setting the EJB JAR Properties |
Specifying Bean-Specific Properties |
Declaring Environment Entries |
Declaring EJB References |
Declaring Resource References |
Defining Transaction Attributes |
Specifying Arbitrary JNDI Names for Your Beans |
Specifying JNDI Names for the Beans References |
Configuring Message-Driven Bean Specific Properties |
Specifying References to Objects Bound in the JNDI |
Message-Driven Bean Example |
Integrating an External JMS Provider |
Naming (JNDI) |
JNDI Registry Service Specific Features |
J2EE Engine Specific Environment Parameters |
Creating an InitialContext |
Integration with Other Services |
Developing Application Clients |
Performing Lookup from Application Client |
Packaging and Deploying Application Client |
Developing Java Persistence |
Java Persistence Infrastructure |
Table Buffer |
Buffer Granularity |
Statements Using the Buffer |
Statements Bypassing the Buffer |
Modifications and Actions on the Remote Buffers |
Buffering Hints |
SQL Trace |
Launching the SQL Trace |
Activating and Deactivating SQL Trace |
Evaluating the SQL Trace |
SQL Trace Filtering |
SQL Trace File Administration |
Statement Pooling |
Java Dictionary |
Modifying Dictionary Preferences |
Development Process |
Creating Data Types |
Initial Values |
Creating Structures |
Reference Fields |
Tables |
Creating Tables |
Buffering Type |
Creating Indexes |
Deploying Tables |
Editing Table Definitions |
Connectivity |
Using the Default DataSource |
Registering a DataSource Alias |
Creating a DataSource |
Reconnecting to the DB in the Event of a DB Crash |
Relational Persistence |
Getting Started with Relational Persistence |
Creating the Database Tables |
Creating the Web Project |
Developing the EmployeeData Class |
Developing the Data Access Interface |
Creating the SQLJ Connection Context |
Creating an SQLJ ResultSet Iterator |
Implementing the Data Access Interface with SQLJ |
Implementing the Data Access Interface with JDBC |
Developing the Web Front End |
Assembling the Application |
Deploying and Running the Application |
Open SQL/JDBC |
Getting a Connection to the Database |
Inserting Data Into a Table |
Using Queries |
Semantics of the Data Types DATE, TIME, and TIMESTAMP |
Transactions in Open SQL/JDBC |
Native SQL Access |
Error Handling |
Open SQL/SQLJ |
Syntax Overview |
Creating and Editing SQLJ Sources |
Database Connection Context |
Execution Context |
Host Variables and Host Expressions |
DML Statements |
ResultSet Iterators |
Single-Row Query |
Handling NULL Values |
SQLJ Batching |
Combining SQLJ and JDBC |
Transactions in Open SQL/SQLJ |
Using the SQLJ Checker |
Debugging SQLJ Sources |
Open SQL Grammar |
Open SQL Data Types |
Character Strings |
Binary Strings |
Using LOBs |
Reading and Writing LOBs En Bloc |
Using Locators |
Using Streams |
Numbers |
Datetime Values |
Object Persistence for Java |
Enterprise Entity Beans |
Java Data Objec |