 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 JSP Files |
| Creating Servlets |
| Creating Filters |
| Creating Listeners |
| JSP Editor |
| HTML Editor |
| Building WARs |
| 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 |
| Mapping Data Using Model Nodes and Model Attributes |
| Providing Data Using Value Nodes and Value Attributes |
| Data Modeler |
| Creating a Data Link |
| Wizards for Forms, Tables, and Buttons |
| 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 Explorer |
| Creating a Project |
| Importing a Project |
| Deleting a Project |
| Navigator |
| Web Dynpro Model Tools |
| Importing an Adaptive RFC Model |
| Adaptive RFC |
| Reusing BAPI Data |
| Multiple Backend-Unterstützung für das Adaptive-RFC-Model |
| Importing a Web Service Model |
| Using External Data Imported from an XMI Model |
| Conditions for an XMI Model Import |
| Declaring a Model to a Component |
| Java Dictionary |
| Dictionary Perspective |
| Development Process |
| Data Types |
| Creating Data Types |
| Open SQL Data Types |
| Initial Values |
| Creating Structures |
| Reference Fields |
| Tables |
| Creating Tables |
| Buffering Type |
| Creating Indexes |
| Deploying Tables |
| 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 |
| 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 |
| 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 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 |
| Web Dynpro Component |
| Window |
| View Set |
| View |
| Action |
| Plugs and Navigation Links |
| Controllers |
| Event |
| Context |
| Data Binding and Mapping |
| Web Dynpro Model |
| Concept |
| Web Dynpro Tools |
| Controller/Context Editor |
| Context Structure |
| Mapping Data Using Model Nodes and Model Attributes |
| Providing Data Using Value Nodes and Value Attributes |
| Data Modeler |
| Creating a Data Link |
| Wizards for Forms, Tables, and Buttons |
| 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 Explorer |
| Creating a Project |
| Importing a Project |
| Deleting a Project |
| Navigator |
| Web Dynpro Model Tools |
| Importing an Adaptive RFC Model |
| Adaptive RFC |
| Reusing BAPI Data |
| Multiple Backend-Unterstützung für das Adaptive-RFC-Model |
| Importing a Web Service Model |
| Using External Data Imported from an XMI Model |
| Conditions for an XMI Model Import |
| Declaring a Model to a Component |
| Procedures |
| Creating the First Application Elements |
| Creating a Project |
| Creating a Web Dynpro Development Component Project |
| Creating a Component |
| Copying a Component |
| Embedding Components |
| Nesting Web Dynpro Components |
| Specifying the Call Sequence of Components |
| Declaring Components |
| 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 Backend-Unterstützung für das Adaptive-RFC-Model |
| Mapping von logischen Systemen |
| Sicherheit von logischen Systemen |
| Importing a Web Service Model |
| Declaring a Model to a Component |
| 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 |
| Wizards for Forms, Tables, and Buttons |
| 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 |
| Declaring a Custom Controller to a Component |
| Editing a Custom Controller |
| Renaming a Custom Controller |
| Creating a Data Link |
| Context Structure |
| Mapping Data Using Model Nodes and Model Attributes |
| 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 |
| Verwenden des Template für die Portal-Ereignis-Steuerung |
| 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-Beispiel zur Darstellung einer Tabelle |
| 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 |
| Event Handling |
| Parameter Mapping |
| Error Handling |
| Messages |
| Processing a Message |
| 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 View Form |
| 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 |
| 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 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 |
| 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 |
| Übersetzung der Texte |
| 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 |
| Using SQL Trace |
| Activating and Deactivating SQL Trace |
| Trace Viewers |
| Technical Details |
| Statement Pooling |
| Tables |
| Creating Tables |
| Creating Indexes |
| Deploying Tables |
| Handling DataSources |
| Using the Default DataSource |
| Deploying a DataSource Alias with an Application |
| Deploying DataSource with an Application or Library |
| 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 |
| Connection to the Database |
| Inserting Data into a Table |
| Selecting Data from a Database |
| Semantics of the Data Types DATE, TIME, and TIMESTAMP |
| Transactions in Open SQL/JDBC |
| Native SQL |
| Error Handling |
| Open SQL / SQLJ |
| Syntax |
| Creating and Editing SQLJ Sources |
| Database Connection Context |
| Execution Context |
| Host Variables and Host Expressions |
| DML-Statements |
| Result Set Iterators |
| Single Row Query |
| NULL Values |
| SQLJ Batching |
| Combining SQLJ and JDBC |
| Transactions |
| Using 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 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 |
| Locks |
| Logical Locks |
| Working with Locks |
| Setting Locks |
| Releasing Locks |
| Web Services |
| 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 |
| 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 |
| Implementation Container |
| Protocol |
| Protocol Interface |
| ProtocolContext Interface |
| Feature Interface |
| Transport Binding |
| Proxy Generation |
| 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</ |