Title and Copyright Information
Preface
- Audience
- Documentation Accessibility
- Diversity and Inclusion
- Related Resources
- Conventions
1 Overview of WebLogic Server Application Development
- WebLogic Server and the Jakarta EE Platform
- Overview of Jakarta EE Applications and Modules
- Web Application Modules
- Jakarta Enterprise Beans Modules
  - EJB Documentation in WebLogic Server
  - Additional EJB Information
- Connector Modules
- Enterprise Applications
  - Jakarta EE Programming Model
  - Packaging and Deployment Overview
- WebLogic Web Services
- JMS and JDBC Modules
- WebLogic Diagnostic Framework Modules
  - Using an External Diagnostics Descriptor
    - Defining an External Diagnostics Descriptor
- Coherence Grid Archive (GAR) Modules
- Bean Validation
- XML Deployment Descriptors
- Deployment Plans
- Development Tools
2 Using Ant Tasks to Configure and Use a WebLogic Server Domain
- Overview of Configuring and Starting Domains Using Ant Tasks
- Starting Servers and Creating Domains Using the wlserver Ant Task
- Configuring a WebLogic Server Domain Using the wlconfig Ant Task
- Example of Creating a Security Realm with the wlconfig Ant Task
- Using the libclasspath Ant Task
3 Using the WebLogic Maven Plug-In
- Installing Maven
- Configuring the WebLogic Maven Plug-In
  - How to use the WebLogic Maven Plug-in
  - Basic Configuration POM File
- Maven Plug-In Goals
  - appc
  - create-domain
  - deploy
  - distribute-app
  - install
  - list-apps
  - purge-tasks
  - redeploy
  - remove-domain
  - start-app
  - start-server
  - stop-app
  - stop-server
  - undeploy
  - uninstall
  - update-app
  - wlst
  - wlst-client
  - ws-clientgen
  - wsgen
  - wsimport
  - ws-wsdlc
  - ws-jwsc
4 Creating a Split Development Directory Environment
- Overview of the Split Development Directory Environment
- Using the Split Development Directory Structure: Main Steps
- Organizing Jakarta EE Components in a Split Development Directory
- Organizing Shared Classes in a Split Development Directory
- Generating a Basic build.xml File Using weblogic.BuildXMLGen
  - weblogic.BuildXMLGen Syntax
- Developing Multiple-EAR Projects Using the Split Development Directory
  - Organizing Libraries and Classes Shared by Multiple EARs
  - Linking Multiple build.xml Files
- Best Practices for Developing WebLogic Server Applications
5 Building Applications in a Split Development Directory
- Compiling Applications Using wlcompile
- Building Modules and Applications Using wlappc
6 Deploying and Packaging from a Split Development Directory
- Deploying Applications Using wldeploy
- Packaging Applications Using wlpackage
7 Developing Applications for Production Redeployment
- What is Production Redeployment?
- Supported and Unsupported Application Types
  - Additional Application Support
- Programming Requirements and Conventions
- Assigning an Application Version
  - Application Version Conventions
- Upgrading Applications to Use Production Redeployment
- Accessing Version Information
8 Using Jakarta EE Annotations and Dependency Injection
- Annotation Processing
- Dependency Injection of Resources
  - Application Life Cycle Annotation Methods
- Standard JDK Annotations
- Standard Security-Related JDK Annotations
9 Using Contexts and Dependency Injection for the Jakarta EE Platform
- About CDI for the Jakarta EE Platform
- Defining a Managed Bean
- Injecting a Bean
- Defining the Scope of a Bean
- Overriding the Scope of a Bean at the Point of Injection
- Using Qualifiers
  - Defining Qualifiers for Implementations of a Bean Type
  - Applying Qualifiers to a Bean
  - Injecting a Qualified Bean
- Providing Alternative Implementations of a Bean Type
  - Defining an Alternative Implementation of a Bean Type
  - Selecting an Alternative Implementation of a Bean Type for an Application
- Applying a Scope and Qualifiers to a Session Bean
  - Applying a Scope to a Session Bean
  - Applying Qualifiers to a Session Bean
- Using Producer Methods, Disposer Methods, and Producer Fields
  - Defining a Producer Method
  - Defining a Disposer Method
  - Defining a Producer Field
- Initializing and Preparing for the Destruction of a Managed Bean
  - Initializing a Managed Bean
  - Preparing for the Destruction of a Managed Bean
- Intercepting Method Invocations and Life Cycle Events of Bean Classes
  - Defining an Interceptor Binding Type
  - Defining an Interceptor Class
  - Identifying Methods for Interception
  - Enabling an Interceptor
  - Applying an Interceptor on a Producer
- Decorating a Managed Bean Class
  - Defining a Decorator Class
  - Enabling a Decorator Class
- Assigning an EL Name to a CDI Bean Class
- Defining and Applying Stereotypes
  - Defining a Stereotype
  - Applying Stereotypes to a Bean
- Using Events for Communications Between Beans
  - Defining an Event Type
  - Sending an Event
  - Handling an Event
- Injecting a Predefined Bean
- Injecting and Qualifying Resources
- Using CDI With JCA Technology
- Configuring a CDI Application
- Enabling and Disabling CDI
  - Enabling and Disabling CDI for a Domain
- Implicit Bean Discovery
  - Enabling and Disabling Implicit Bean Discovery for a Domain
- Supporting Third-Party Portable Extensions
- Using the Built-in Annotation Literals
- Using the Configurator Interfaces
- Bootstrapping a CDI Container
10 Jakarta JSON Processing
- About JavaScript Object Notation (JSON)
- Object Model API
- Streaming API
  - Reading JSON Data Using a Parser
  - Writing JSON Data Using a Generator
- New Features for JSON Processing
11 Jakarta JSON Binding
- About Default Mapping
- About Customized Mapping
- Standard Support to Handle Application or JSON Media Type for JAX-RS
12 Understanding WebLogic Server Application Classloading
- Java Classloading
- WebLogic Server Application Classloading
- Resolving Class References Between Modules and Applications
- Using the Classloader Analysis Tool (CAT)
- Sharing Applications and Modules By Using Jakarta EE Libraries
- Adding JARs to the Domain /lib Directory
13 Creating Shared Jakarta EE Libraries and Optional Packages
- Overview of Shared Jakarta EE Libraries and Optional Packages
- Creating Shared Jakarta EE Libraries
- Referencing Shared Jakarta EE Libraries in an Enterprise Application
  - Overriding context-roots Within a Referenced Enterprise Library
  - URIs for Shared Jakarta EE Libraries Deployed As a Standalone Module
- Referencing Optional Packages from a Jakarta EE Application or Module
- Using weblogic.appmerge to Merge Libraries
  - Using weblogic.appmerge from the CLI
  - Using weblogic.appmerge as an Ant Task
- Integrating Shared Jakarta EE Libraries with the Split Development Directory Environment
- Deploying Shared Jakarta EE Libraries and Dependent Applications
- Web Application Shared Jakarta EE Library Information
- Using WebApp Libraries With Web Applications
- Accessing Registered Shared Jakarta EE Library Information with LibraryRuntimeMBean
- Order of Precedence of Modules When Referencing Shared Jakarta EE Libraries
- Best Practices for Using Shared Jakarta EE Libraries
14 Programming Application Life Cycle Events
- Understanding Application Life Cycle Events
- Registering Events in weblogic-application.xml
- Programming Basic Life Cycle Listener Functionality
  - Configuring a Role-Based Application Life Cycle Listener
- Examples of Configuring Life Cycle Events with and without the URI Parameter
- Understanding Application Life Cycle Event Behavior During Redeployment
- Programming Application Version Life Cycle Events
15 Programming Context Propagation
- Understanding Context Propagation
- Programming Context Propagation: Main Steps
- Programming Context Propagation in a Client
- Programming Context Propagation in an Application
16 Programming Jakarta Mail with WebLogic Server
- Overview of Using Jakarta Mail with WebLogic Server Applications
- Understanding Jakarta Mail Configuration Files
- Configuring Jakarta Mail for WebLogic Server
- Sending Messages with Jakarta Mail
- Reading Messages with Jakarta Mail
17 Threading and Clustering Topics
- Using Threads in WebLogic Server
- Using the Work Manager API for Lower-Level Threading
- Programming Applications for WebLogic Server Clusters
18 Developing OSGi Bundles for WebLogic Server Applications
- Understanding OSGi
- Features Provided in WebLogic Server OSGi Implementation
- Configuring the OSGi Framework
- Creating OSGi Bundles
- Deploying OSGi Bundles
  - Preparing to Deploy an OSGi Bundle on a Target System
  - Deploying OSGi Bundles in the osgi-lib Directory
    - Setting the Start Level and Run Level for a Bundle
- Accessing Deployed Bundle Objects From JNDI
- Using OSGi Logging Via WebLogic Server
- Configuring a Filtering ClassLoader for OSGi Bundles
- OSGI Example
19 Using the WebSocket Protocol in WebLogic Server
- Understanding the WebSocket Protocol
  - Limitations of the HTTP Request-Response Model
  - WebSocket Endpoints
  - Handshake Requests in the WebSocket Protocol
  - Messaging and Data Transfer in the WebSocket Protocol
- Understanding the WebLogic Server WebSocket Implementation
  - WebSocket Protocol Implementation
  - WebLogic WebSocket Java API
  - Protocol Fallback for WebSocket Messaging
  - Sample WebSocket Applications
- Overview of Creating a WebSocket Application
- Creating an Endpoint
  - Creating an Annotated Endpoint
  - Creating a Programmatic Endpoint
  - Specifying the Path Within an Application to a Programmatic Endpoint
- Handling Life Cycle Events for a WebSocket Connection
  - Handling Life Cycle Events in an Annotated WebSocket Endpoint
  - Handling Life Cycle Events in a Programmatic WebSocket Endpoint
- Defining, Injecting, and Accessing a Resource for a WebSocket Endpoint
- Sending a Message
  - Sending a Message to a Single Peer of an Endpoint
  - Sending a Message to All Peers of an Endpoint
  - Ensuring Thread Safety for WebSocket Endpoints
- Encoding and Decoding a WebSocket Message
  - Encoding a Java Object as a WebSocket Message
  - Decoding a WebSocket Message as a Java Object
- Specifying a Part of an Endpoint Deployment URI as an Application Parameter
- Maintaining Client State
- Configuring a Server Endpoint Programmatically
- Building Applications that Use the Jakarta API for WebSocket
- Deploying a WebSocket Application
- Monitoring WebSocket Applications
- Using WebSockets with Proxy Servers
- Writing a WebSocket Client
  - Writing a Browser-Based WebSocket Client
  - Writing a Java WebSocket Client
- Securing a WebSocket Application
  - Applying Verified-Origin Policies
  - Authenticating and Authorizing WebSocket Clients
    - Authorizing WebSocket Clients
  - Establishing Secure WebSocket Connections
  - Avoiding Mixed Content
  - Specifying Limits for a WebSocket Connection
- Enabling Protocol Fallback for WebSocket Messaging
  - Using the JavaScript API for WebSocket Fallback in Client Applications
  - Packaging and Specifying the Location of the WebSocket Fallback Client Library
  - Enabling WebSocket Fallback
- Migrating an Application to the JSR 356 Java API for WebSocket from the Deprecated API
  - Comparison of the JSR 356 API and Proprietary WebLogic Server WebSocket API
  - Converting a Proprietary WebSocket Server Endpoint to Use the JSR 356 API
  - Replacing the /* Suffix in a Path Pattern String
    - Replacing a /* Suffix that Represents Variable Path Parameters in an Endpoint URI
    - Replacing a /* Suffix that Represents Additional Data for an Endpoint
  - Example of Converting a Proprietary WebSocket Server Endpoint to Use the JSR 356 API
- Example of Using the Java API for WebSocket with WebLogic Server
A Enterprise Application Deployment Descriptor Elements
- weblogic-application.xml Deployment Descriptor Elements
- weblogic-application.xml Schema
- application.xml Schema
B wldeploy Ant Task Reference
- Overview of the wldeploy Ant Task
- Basic Steps for Using wldeploy
- Sample build.xml Files for wldeploy
- wldeploy Ant Task Attribute Reference
  - Main Attributes
  - Nested <files> Child Element