Developer detailed usage information
Developer detailed usage information provides a variety of procedural guidance and facts for using various programming packages and classes.
We can also search for developer detailed usage information using keywords.
- About Apache Derby
The Apache Derby package that is bundled with the application server is backed by full IBM Quality Assurance (QA).
- Access intent exceptions
The following are exceptions that occur in response to the application of access intent policies.
- AccessIntent interface
The AccessIntent interface is available to bean-managed persistence (BMP) entity beans.
- Access intent -- isolation levels and update locks
WebSphere Application Server access intent policies provide a consistent way of defining the isolation level for CMP bean data across the different relational databases in our environment.
- Access intent troubleshooting tips
The following frequently asked questions involving access intent are answered.
- ActiveX client programming, Java field programming tips
Using the ActiveX to EJB bridge to access Java fields has the same case sensitivity issue that it has when invoking methods. Field names must use the same case as the Java field syntax.
- ActiveX client programming, JClassProxy and JObjectProxy classes
The majority of tasks for accessing your Java classes and objects are handled with the JClassProxy and JObjectProxy objects.
- ActiveX client programming, threading tips
The ActiveX to EJB bridge supports both free-threaded and apartment-threaded access and implements the Free Threaded arshaler to work in a hybrid environment such as Active Server Pages (ASP). Each thread created in the ActiveX process is mirrored in the Java environment when the thread communicates through the ActiveX to EJB bridge.
- ActiveX client programming, tips for passing arrays
Arrays are very similar between Java and Automation containers like Visual Basic and VBScript. This topic provides some important points to consider when passing arrays back and forth between these containers.
- ActiveX client programming best practices
The best way to access Java components is to use the Java language. IBM recommends that we do as much programming as possible in the Java language and use a small simple interface between your COM Automation container (for example, Visual Basic) and the Java code. This interface avoids any overhead and performance problems that can occur when moving across the interface.
- ActiveX to Java primitive data type conversion values
All primitive Java data types are automatically converted to native ActiveX Automation types. However, not all Automation data types are converted to Java types (for example, VT_DATE). Variant data types are used for data conversion.
- Aggregation tag library attributes
The aggregation tag library is used to aggregate multiple portlets on one page.
- (iSeries) (ZOS) (Dist) Artifacts used to develop web services
With development artifacts, we can develop an enterprise bean or a JavaBeans module into web services that are based on the Web Services for Java EE specification.
- Business activity API
Use the business activity application programming interface (API) to create business activities and compensation handlers for an application component, and to log data required to compensate an activity if there is a failure in the overall business activity.
The ByteReaderPattern pattern is used to read byte data from a file.
The ByteWriterPattern pattern is used to write byte data to a file.
- CacheableCommandImpl class
Commands are implemented by extending the class CacheableCommandImpl, which implements the CacheableCommand interface.
- Certificate mapping file entries
The following is the syntax for entries in a certificate mapping file.
- Choosing the verify parts methods using the WSSVerifyPart API
We can configure the signing verification information for the consumer binding using the WSS API. The transform algorithm and digest methods are used for the consumer binding. Use the WSSVerifyPart API to configure the algorithm methods. The WSSVerifyPart API is provided in the com.ibm.websphere.wssecurity.wssapi.verification package.
- ClientLauncher class
The class, com.ibm.websphere.client.installer.ClientLauncher, contains a main() method called by Java Web Start (JWS) to launch the client application. The Java Web Start client is used with platforms that support a web browser.
- ClientRuntimeInstaller class
This section provides information on the ClientRuntimeInstaller class.
- Client-side programming tips for the Object Request Broker service
Every Internet InterORB Protocol (IIOP) request and response exchange consists of a client-side ORB and a server-side ORB. It is important that any application that uses IIOP is properly programmed to communicate with the client-side Object Request Broker (ORB).
- Clustered environment considerations for timer service
In a single server environment, it is clear which server instance should invoke the timeout method of the bean on a given bean. In a multi-server clustered environment there are other considerations governing the behavior.
- Command class
Extend one or more of the three interfaces included in the command package to write a command interface. The base interface for all commands is the Command interface.
- Component identification for source and reporter
The component identification fields in the Common Base Event are used to indicate which component in the system is experiencing the condition that is described by the event (the sourceComponentID) and which component emitted the event (the reporterComponentID).
- Connection considerations when migrating servlets, JavaServer Pages, or enterprise session beans
If we plan to upgrade to WAS v7.0 or later, and migrate applications from version 1.2 of the Java 2 Platform, Enterprise Edition (J2EE) specification to a later version, such as 1.4 or Java EE, be aware that the product allocates shareable and unshareable connections differently for post-version 1.2 application components. For some applications, that difference can result in performance degradation.
- Considerations for isolated resource providers
There are some design considerations that we should be aware of when working with resource providers that we have specified to be isolated in their own class loaders.
- Container managed persistence bean associated technologies
WAS delivers container-managed persistence (CMP) services beyond the standards set by the EJB specification.
- Container-managed persistence restrictions and exceptions
Some external software that directly impact the applications can limit container-managed persistence (CMP) features. However, we can work around these limitations.
- Create stubs command
The createEJBStubs command creates stub classes for remote interfaces of EJB Version 3.0 beans packaged in Java archive (JAR) or Enterprise archive (EAR) files. It also provides an option to create a single stub class from an interface class located in a directory or a JAR file. Several command options are provided to package the generated stub classes in different ways. See the Syntax and Examples sections later in this topic for more details.
- Create stubs command
The createEJBStubs command creates stub classes for remote interfaces of EJB beans packaged in JAR, web application archive (WAR), or EAR files. It also provides an option to create a single stub class from an interface class located in a directory or a JAR file. Several command options are provided to package the generated stub classes in different ways. See the Syntax and Examples sections for more details.
- Criteria API
The Criteria API is an API for building queries with Java objects, as an alternative to building strings for Java Persistence Query Language (JPQL) queries.
- Custody and Ownership Transfer API for the UDDI Version 3 registry
Use the UDDI Custody and Ownership Transfer API to transfer custody or ownership of one or more entities contained in a UDDI Version 3 registry. The UDDI Version 3 registry supports only intra-node ownership transfer; it does not support inter-node custody transfer.
- CustomBinder interface for JAX-RPC applications
WAS defines a CustomBinder interface that we can implement for Java API for XML-based Remote Call Procedure (JAX-RPC) applications to provide concrete custom data binders for a specific XML schema type.
- Data access bean types
For easy data access programming, WAS provides a special class library that implements many methods of the JDBC API for you. The library is essentially a set of Service Data Objects (SDO).
- Data access portability features
These interfaces work with the relational resource adapter (RRA) to make database-specific functions operable on connections between the application server and that database.
- DataGraph schema
- dbmodify tag JavaServer Pages syntax (deprecated)
The <tsx:dbmodify> tag establishes a connection to a database and then adds records to a database table.
- dbquery tag JavaServer Pages syntax (deprecated)
Use the <tsx:dbquery> tag to establish a connection to a database, submit database queries, and return the results set.
- Decryption methods
The decryption algorithms specify the data and key encryption algorithms used to decrypt the SOAP message. The WSS API for decryption (WSSDecryption) specifies the algorithm uniform resource identifier (URI) of the data and key encryption methods. The WSSDecryption interface is part of the com.ibm.websphere.wssecurity.wssapi.decryption package.
- Default Application
WAS provides a default configuration that administrators can use to verify that the Application Server is running. When the product is installed, it includes an application server called server1 and an enterprise application called Default Application.
- Digital signing methods using the WSSSignature API
We can configure the signing information for the generator binding using the WSS API. To configure the client for request signing, choose the digital signing methods. The algorithm methods include the signing and canonicalization methods.
- Dynamic and static object types for the JDBC DMS
DataObjects of the Service Data Object (SDO) 1.0 Specification can use static types as well as dynamic types. If you know that a particular dataGraph schema meets all of the application query requirements, we can generate static SDO code for potential runtime benefits.
- Dynamic query API: prepareQuery() and executePlan() methods
Use these methods to more efficiently allocate the overhead associated with dynamic query. They are equivalent in function to the prepareStatement() and executeQuery() methods of the JDBC API.
- EJB 3.x interceptors
An interceptor is a method that is automatically called when the business methods of an EJB are invoked or lifecycle events of an EJB occur.
- EJB data mediator service data retrieval
An EJB mediator request is a compound EJB query. We can obtain a DataGraph using the getGraph call.
- EJB data mediator service data update
An EJB mediator request is a compound EJB query. We can write an updated DataGraph back to the data source using the applyChanges method.
- EJB data mediator service programming considerations
When we begin writing the applications to take advantage of the EJB data mediator service (DMS) provided in the product, consider the following items.
- EJB metadata annotations
Annotations enable you to write metadata for EJB inside your source code. Use them instead of extensible markup language (XML) deployment descriptor files. Annotations can also be used with descriptor files.
- EJB query: BNF syntax
The Backus-Naur Form (BNF) is one of the most commonly used notations for specifying the syntax of programming languages or command sets. This article lists the syntax for Enterprise JavaBeans (EJB) query language.
- EJB query: Reserved words
The following words are reserved in WAS EJB queries.
- EJB query: Scalar functions
EJB query contains scalar built-in functions for doing type conversions, string manipulation, and for manipulating date-time values.
- Encryption methods
For request generator binding settings, the encryption methods include specifying the data and key encryption algorithms to use to encrypt the SOAP message. The WSS API for encryption (WSSEncryption) specifies the algorithm name and the matching algorithm uniform resource identifier (URI) for the data and key encryption methods. If the data and key encryption algorithms are specified, only elements that are encrypted with those algorithms are accepted.
- Enterprise bean development best practices
Use the following guidelines when designing and developing enterprise beans.
- Error handling in mediations
The actions taken in the event of an error occurring during mediation processing are summarized in the following table:
- Example: Publishing a business, service, and technical model using the UDDI registry user interface
This example describes how to use the UDDI registry user interface to publish a used car business called Modern Cars to the UDDI registry, and how to publish a service and technical model for the business.
- Exposing methods in SEI-based JAX-WS web services
Use the @WebService and @WebMethod annotations on a service endpoint implementation to specify Java methods to expose as JAX-WS web services.
- Extended data
The Common Base Event provides several methods for including this additional data, including extending the Common Base Event schema or supplying one or more ExtendedDataElement elements within the Common Base Event, which is the preferred approach.
- Extensions to data access APIs
If a single data access API does not provide a complete solution for the applications, use WAS extensions to achieve interoperability between both the JCA and JDBC APIs.
The FileReaderPattern pattern is used to read text data from a file.
- FileRegistrySample.java file
This provides an example of the FileRegistrySample.java file.
The FileWriterPattern pattern is used to write text data to a file.
- FindQualifier values for API functions in the UDDI registry
The find_xx API functions (find_business, find_service, find_binding, find_tModel and find_relatedBusinesses) accept an optional findQualifiers argument, which can contain multiple findQualifier values.
- Frequently asked questions about web services
This topic presents frequently asked questions about the development and implementation of web services.
- Generate Common Base Event content with the default event factory
A default Common Base Event content handler populates Common Base Events with WAS runtime information. This content handler can also use a Common Base Event template to populate Common Base Events.
- Generated .java files
When the JSP engine's keepgenerated configuration parameter is set to true, the .java file generated for JavaServer Pages (JSP) is retained. The .java file contains information that is useful in debugging.
- HTTP GET services for UDDI registry data structures
The UDDI registry offers an HTTP GET service for access to the XML representations of the businessEntity, businessService, bindingTemplate, and tModel UDDI data structures. The Uniform Resource Locators (URLs) at which these structures are accessible use the entity key as a URL parameter. The XML element that is returned is a businessDetail, serviceDetail, bindingDetail or tModelDetail element, according to the type of entity key supplied.
- IBM proprietary SOAP over JMS protocol (deprecated)
Use a SOAP over JMS transport as an alternative to HTTP for communicating SOAP messages between clients and servers. The web services engine supports the use of an IBM proprietary implementation as well as the industry standard implementation.
- Inquiry API for the UDDI Version 3 registry
The Inquiry API provides four forms of query that follow broadly used conventions that match the needs of software that is traditionally used in registries.
- Inquiry API functions in the UDDI registry
Use the Inquiry API set to locate and obtain details about entries in a UDDI registry.
- Interfaces that support JACC
WAS provides the RoleConfigurationFactory and the RoleConfiguration interfaces, which are similar to PolicyConfigurationFactory and PolicyConfiguration interfaces so the information stored in the bindings file can be propagated to the provider during installation. The implementation of these interfaces is optional.
- Internationalization context API: Programming reference
Application components programmatically manage internationalization context through the UserInternationalization, Internationalization, and InvocationInternationalization interfaces in the com.ibm.websphere.i18n.context package.
- J2C principal mapping modules
We can develop our own J2EE Connector (J2C) mapping module if the application requires more sophisticated mapping functions. The mapping login module that we might have developed on WAS v5.x is still supported in WAS v6.0.x and later.
- java.util.logging -- Java logging programming interface
The java.util.logging.Logger class provides a variety of methods with which data can be logged.
- JavaMail API security permissions best practices
In many of its activities, the JavaMail API needs to access certain configuration files. The JavaMail and JavaBeans Activation Framework binary packages themselves already contain the necessary configuration files. However, the JavaMail API allows the user to define user-specific and installation-specific configuration files to meet special requirements.
- Java Management Extensions V1.0 to Java Management Extensions V1.2 migration
We might need to migrate custom MBeans that are supplied by products other than the Application Server from v5 to v6.0 and later for full compatibility.
- JAX-WS annotations
JAX-WS relies on the use of annotations to specify metadata associated with web services implementations and to simplify the development of web services. Annotations describe how a server-side service implementation is accessed as a web service or how a client-side Java class accesses web services.
This pattern is used to implement the business logic of processing data from a JDBC connection using a stored procedure. The administrative tasks of opening and closing the connection are done by the batch framework.
This pattern is used to implement the business logic of outputting data to a JDBC connection using a stored procedure. The administrative tasks of opening and closing the connection are done by the batch framework.
- JDBC mediator exceptions
JDBC mediator exceptions either surface errors reported by the database, or indicate use of non-valid metadata in the attempt to instantiate the DMS.
- JDBC mediator generated query
If we do not provide a structured query language (SQL) SELECT statement, then the data mediator service (DMS) generates one using the metadata provided at instance creation.
- JDBC mediator integration with presentation layer
The JDBC Data Mediator Service (DMS) can be used in conjunction with web application presentation layer technologies such as JavaServer Pages Standard Tag Library (JSTL) and JavaServer Faces (JSF).
- JDBC mediator paging
Paging can be useful for moving through large data sets because it can limit the amount of data pulled into memory at any given time. The JDBC DMS API provides two interfaces that implement paging.
- JDBC mediator performance considerations and limitations
Use these tips to help determine if a JDBC Data Mediator Service suits the requirements of the application serving environment.
- JDBC mediator serialization
The DataGraph produced by the JDBC DMS can be serialized and written out to a file, or sent across a network.
- JDBC mediator supplied query
An SDO client can supply the JDBC Data Mediator Service (DMS) with a SELECT statement to replace the statement generated from the DMS metadata.
- JDBC mediator transactions
We can specify that the JDBC mediator either act as transaction manager, or refrain from such activities in the case of external transaction management (performed by the SDO client).
This pattern is used to retrieve data from a database using a Java Database Connectivity (JDBC) connection.
The JDBCWriterPattern pattern is used to write data to a database using a JDBC connection.
- JMS_IBM properties and equivalent SI_system properties
Support is provided by the SIMessage interface and the mediation configuration selector for JMS_IBM properties and the equivalent SI_system properties. We can access JMS_IBM_ properties through the JMS API. Many of the values held by JMS_IBM_ properties apply to an SIMessage and have SI_ synonyms. We can access all these properties through the SIMessage interface, and can match and set many of them. We cannot set exception properties because they are controlled by the messaging engine.
- JMS Formats - bytes
Your program can retrieve the payload of a JMS bytes message by mapping the body of the message to an SDO data graph representing the message.
- JMS Formats - object
Your program can retrieve the payload of a JMS object message by mapping the body of the message to an SDO data graph representing the message.
- JMS formats - Stream
Your program can retrieve the payload of a JMS stream message by mapping the body of the message to an SDO data graph representing the message.
- JMS Formats - text
Your program can retrieve the payload of a JMS text message by mapping the body of the message to an SDO data graph representing the message.
- JMS headers
Support is provided by the SIMessage interface and the mediation configuration selector for JMS headers properties. JMS headers properties match in the SIMessage interface in the same way as they do for the JMS API, but we can only modify properties that map to SIMessage metadata.
- JMS interfaces
WAS supports applications that use JMS 1.1 domain-independent interfaces (referred to as "common interfaces" in the JMS specification) and JMS 1.0.2 domain-specific interfaces.
- JMS message header: The TimeToLive property reference
The range of permitted values for the TimeToLive property of a JMS message that WSIF puts onto a queue.
- JMS report messages
JMS applications can use report messages as a form of managed request/response processing, to give remote feedback to producers on the outcome of their send operations and the fate of their messages.
- JMSX properties
Support is provided by the SIMessage interface and the mediation configuration selector for JMSX properties. Use the SIMessage interface to match and access supported JMSX properties defined in the JMS API. We can only use the SIMessage interface to set properties that are not defined as set by the JMS provider.
- Job scheduler System Programming Interfaces (SPI)
Use SPIs to manage a list of groups to which a user is assigned, to control user actions against jobs, to suppress the writing of log lines, and to provide an installation-specific audit string validation rule.
The JPAReaderPattern pattern is used to retrieve data from a database using OpenJPA.
The JPAWriterPattern pattern is used to write data to a database using a Java Persistence API (JPA) connection.
- JRas extension classes
WAS provides a base set of implementation classes that are collectively referred to as the JRas extensions. Many of these classes provide the appropriate implementations of loggers, handlers, and formatters for use in a WAS environment.
- JRas Extensions
JRas extensions are the collection of implementation classes that support JRas integration into the WAS environment.
- JRas messages and trace event types
The basic JRas message and event types are not the same as those natively recognized by WAS, so the JRas types are mapped onto the types that are native to the runtime environment. We can control the way JRas message and trace events are processed using custom filters and message controls.
- JRas programming interfaces for logging (deprecated)
The JRas framework described in this task and its sub-tasks is deprecated. However, we can achieve similar results using Java logging.
- JRas resource bundles
Create resource bundles in several ways. The best and easiest way is to create a properties file that supports a PropertiesResourceBundle resource bundle. This sample shows how to create such a properties file.
- LocalizableTextFormatter class
The LocalizableTextFormatter class, found in the com.ibm.websphere.i18n.localizabletext package, is the primary programming interface for using the localizable-text package. Instances of this class contain the information needed to create language-specific strings from keys and resource bundles.
- Localization API support
The com.ibm.websphere.i18n.localizabletext package contains classes and interfaces for localizing text.
- Local transaction containment
IBM WAS supports local transaction containment (LTC), which we can configure using local transaction extended deployment descriptors. LTC support provides certain advantages to application programmers. Use the scenarios provided, and the list of points to consider, to help we decide the best way to configure transaction support for local transactions.
- Management of UDDI node configuration properties
Use the UDDI registry administrative interface to manage the UDDI node runtime behavior by setting the configuration properties.
- Management of UDDI node policies
Use the UDDI registry administrative interface to manage policies that affect the UDDI API.
- Management of UDDI node states and attributes
Use the UDDI registry administrative interface to manage the information about a UDDI node and its activation state.
- Management of UDDI node tiers
Use the UDDI registry administrative interface to set publish tier limits, which control the number of each type of UDDI entity that a publisher can save in the UDDI registry.
- Management of UDDI node value sets
Use the UDDI registry administrative interface to inspect and manage the runtime configuration of a UDDI application. We can manage the information about a UDDI node and its activation state, update properties and policies, set publish tier limits, register UDDI publishers, and control value set support.
- Management of UDDI publishers
Use the UDDI registry administrative interface to register UDDI publishers.
- (iSeries) (ZOS) (Dist) Mapping between Java language, WSDL and XML for JAX-RPC applications
Data for Java API for XML-based Remote Procedure Call (JAX-RPC) applications flows as extensible Markup Language (XML). JAX-RPC applications use mappings to describe the data conversion between the Java language and extensible Markup Language (XML) technologies, including XML Schema, WSDL and SOAP supported by the application server.
- (iSeries) (ZOS) (Dist) Mapping between Java language, WSDL and XML for JAX-WS applications
Data for JAX-WS applications flows as extensible Markup Language (XML). JAX-WS applications use mappings to describe the data conversion between the Java language and extensible Markup Language (XML) technologies, including XML Schema, Web Services Description Language (WSDL) and SOAP supported by the application server.
- Mapping of SDO data graphs for web services messages
The structure of web services messages is described by the Service Data Objects (SDO) Version 1 data graphs for web services messages.
- Mapping XML schema definitions to the SDO type system
Each XML schema type is mapped to an SDO type. Use this mapping to help you develop code to navigate the data graphs of the messages that your program mediates.
The public interface MediationHandler has just one method: handle. This method is used by the runtime to invoke a mediation.
- MessageConverter class
The com.ibm.websphere.logging.MessageConverter class provides a method to convert a message ID at the front of a String into either a new message ID or an old message ID. The direction of the conversion is controlled with the conversionType argument.
- Message header information
The non-routing SIMessage header fields, and the methods available to work with them, can be mapped to JMS message header fields.
- Message properties support for mediations
The SIMessage metadata properties enable the main data types, and are supported by JMS Message Selectors.
- Naming roles
The Java 2 Platform, Enterprise Edition (J2EE) role-based authorization concept is extended to protect the CosNaming service.
- Notifications from the application server Web Services Distributed Management resources
Use this topic to learn about application server Web Services Distributed Management (WSDM) resources and their life cycle events.
- NotificationSink interface
A notification sink is a user-defined stateless session bean called when the task changes state.
- Performance Monitoring Infrastructure client package
Use this page to learn how to use the PmiClient application and JMX connector to communicate to the Perf MBean in an application server.
- PMI client interface (deprecated)
The data provided by the Performance Monitoring Infrastructure (PMI) client interface is documented here.
- Portlet and PortletApplication MBeans
The MBeans of type portlet and portletapplication provide information about a given portlet application and its portlets. Through the MBean of type portletapplication, we can retrieve a list of names of all portlets that belong to a portlet application. By querying the MBean of type portlet with a given portlet name, we can retrieve portlet specific information from the MBean of type portlet.
- Precedence for modify command parameters, request-level RAS attributes, and server-wide properties
Three ways exist to define Reliability Availability and Serviceability (RAS) attribute values: server-wide properties, request-level RAS attributes, or modify command parameters. Modify command parameters have precedence over associated RAS attributes and server-wide properties, while the RAS attributes have precedence over the associated server-wide properties.
- Publish API for the UDDI Version 3 registry
Use the UDDI Publish API to publish, delete, and update information contained in a UDDI registry. The messages defined in this section all behave synchronously.
Use this pattern is used to read data from a database using IBM Optim™ pureQuery Runtime. The batch data stream (BDS) framework completes the administrative tasks of opening and closing connections.
Use this pattern to write data to a database using IBM Optim pureQuery Runtime. The batch data stream (BDS) framework completes the administrative tasks of opening and closing connections.
The RecordOrientedDatasetReaderPattern pattern is used to read data from a z/OS data set.
The RecordOrientedDataSetWriterPattern pattern is used to write data to a z/OS data set.
- Remote dispatcher property settings
Configure the sending of include requests between the application and remote resources.
- Remote request dispatcher considerations
This topic presents some considerations of which we need to be aware when using remote request dispatcher.
- Result.java file
This module is used by user registries in WAS when calling the getUsers and getGroups methods. The user registries use this method to set the list of users and groups and to indicate if more users and groups in the user registry exist than requested.
- RMF report examples
The Workload Manager data collected by Resource Measurement Facility (RMF™) is captured and displayed in a report.
- RMF Workload Activity reports and RMF Monitor III
Performance metrics include transaction rates and response times. Resource utilization includes CPU, I/O (channel), and storage utilization.
- Runtime considerations for SIP application developers
We should consider certain product runtime behaviors when we are writing SIP applications.
- SAML token library APIs
The SAML token library application programming interfaces (APIs) provide methods we can use to create, validate, parse, and extract SAML tokens.
- Scheduler interface
Use the com.ibm.websphere.scheduler.Scheduler Java object (in the JNDI namespace for the scheduler configuration) to find a reference to a scheduler and work with tasks.
- Security API for the UDDI Version 3 registry
The UDDI Version 3 registry has an independent Security API, unlike UDDI Version 1 and v2, where the Security API is part of the Publish API.
- Servlet extension interfaces
- Servlet security methods
The authenticate, login, logout, getRemoteUser, isUserInRole and getAuthType servlet security methods are methods of the javax.servlet.http.HttpServletRequest interface.
- sib: URL syntax
The SIDestinationAddress public interface represents a service integration bus destination.
The SIDestinationAddressFactory public interface extends java.lang.Object, and creates an SIDestinationAddressFactory at static initialization that is subsequently used for the creation of all instances of SIDestinationAddress.
- Signature verification methods using the WSSVerification API
We can verify the signing or signature information using the WSS API for the consumer binding. The signature and canonicalization algorithm methods are used for the generator binding. The WSSVerification API is provided in the com.ibm.websphere.wssecurity.wssapi.verification package.
- Signed parts methods using the WSSSignPart API
We can configure the signed parts information for the generator binding using the WSS API. The algorithms include the digest and transform methods.
The SIMediationSession public interface defines the methods for querying and interacting with the service integration bus. As well as defining the methods for working with the service integration bus, this interface also includes methods that provide information about where the mediation is invoked from, and the criteria that are applied before the message is mediated.
The SIMessage interface is the public interface to a service integration bus message for use by mediations and other service integration bus components. This interface extends java.lang.Cloneable and java.lang.Serializable.
Public interface SIMessageContext extends javax.xml.rpc.handler.MessageContext. This is the object required on the interface of a mediation handler. In addition to the context information that might be passed from one handler to another, it can return a reference to an SIMessage and an SIMediationSession.
- SIMessage metadata properties
The SIMessage metadata properties contain message metadata we can use in mediation configuration selectors. We can work with these properties using the SIMessage interface.
- SIP timer summary
Request for Comments (RFC) 3261, "SIP: Session Initiation Protocol," specifies various timers that SIP uses.
- SOAP over JMS protocol
The web services engine supports the use of an emerging industry standard SOAP over Java Message Service (JMS)-compliant messaging transport as an alternative to HTTP for communicating SOAP messages between clients and servers.
- Summary of controls
Each controller, servant, and client must have its own MVS™ user ID. When a request flows from a client to the cluster or from a cluster to a cluster, WAS for z/OS passes the user identity (client or cluster) with the request. Thus, each request is performed on behalf of the user identity and the system checks to see if the user identity has the authority to make such a request. The tables outline System Authorization Facility (SAF) and non-SAF authorizations.
- TaskHandler interface
A task handler is a user-defined stateless session bean called by tasks created using a BeanTaskInfo object.
- TaskInfo interface
TaskInfo objects contain the information to create a task. Several implementations of this class exist, one for each type of task that can run.
- TaskNameManager interface
The TaskNameManager is the programmatic interface to the application profiling function. Because on rare occasions it may be necessary to programmatically set the current task name, the TaskNameManager interface enables both overriding of the current task associated with the thread of execution and resetting of the current task with the original task.
- The createQueue or createTopic method and the default messaging provider
Use the Session.createQueue(String) method or Session.createTopic(String) method instead of using JNDI lookup to create a JMS Queue or JMS Topic with the default messaging provider.
- The Work area partition manager interface
Applications interact with the work areas partition service using the work areas partition manager interface. A user can retrieve an instance of the work areas partition manager interface out of naming and use the methods defined in the following section.
- Transaction service exceptions
The exceptions that the WAS transaction service can throw are listed with a summary of each exception.
- Trust association interceptor support for Subject creation
The trust association interceptor (TAI) com.ibm.wsspi.security.tai.TrustAssociationInterceptor interface supports several features that are different from the existing com.ibm.websphere.security.TrustAssociationInterceptor interface.
- tsx:dbconnect tag JavaServer Pages syntax (deprecated)
Use the <tsx:dbconnect> tag to specify information needed to make a connection to a database through Java DataBase Connectivity (JDBC) or Open Database Connectivity (ODBC) technology.
- tsx:getProperty tag JavaServer Pages syntax and examples (deprecated)
The <tsx:getProperty> tag gets the value of a bean to display in a JavaServer Pages (JSP) file.
- tsx:repeat tag JavaServer Pages syntax (deprecated)
The <tsx:repeat> tag repeats a block of HTML tagging.
- tsx:userid and tsx:passwd tag JavaServer Pages syntax (deprecated)
With the <tsx:userid> and <tsx:passwd> tags, we do not have to hard code a user ID and password in the <tsx:dbconnect> tag.
- UDDI registry administrative (JMX) interface
Use the UDDI registry administrative interface to inspect and manage the runtime configuration of a UDDI application. We can manage the information about a UDDI node and its activation state, update properties and policies, set publish tier limits, register UDDI publishers, and control value set support.
- UDDI registry SOAP service end points
UDDI Version 3 supports multiple versions of SOAP API services. Depending on the security settings for WAS and the user data constraint transport guarantee settings for the UDDI SOAP service, UDDI Version 3 supports different end points for different services.
- UDDI Version 3 Client
Use the UDDI Version 3 Client for Java to access the UDDI Version 3 APIs from Java client code.
- Unknown primary-key class
When writing an entity bean, the minimum requirements usually include a primary-key class. However, in some cases we might choose not to specify the primary-key class for an entity bean with container-managed persistence (CMP).
- Usage patterns for deploying custom data binders for JAX-RPC applications
Custom data binders are used to map XML schema types with Java objects. Custom data binders provide bindings for XML schema types that are not supported by the current Java API for XML-based Remote Call Procedure (JAX-RPC) specification. WAS provides an extension to the Web Services for Java EE programming model called the CustomBinder interface that implements these custom bindings for a specific XML schema type. The custom binding provider is the package for the custom data binders that is imported into the runtime.
- UserCalendar interface
A user calendar is a user-defined stateless session bean called by tasks when they need to calculate date-related values.
- User properties
Support for user properties is provided by the SIMessage interface and the mediation configuration selector. The JMS API supports user properties of primitive wrapper or string types. The property name can be any valid Java identifier providing it does not have the prefix JMS. The SIMessage API also supports user properties of primitive wrapper or string types, and additionally supports byte and serializable types. Arbitrary serializable objects are stored as byte arrays, and are selected on as byte arrays only (using equals only).
- UserRegistry.java files
The following file is a custom property used with a custom user registry.
- Use the JMS_IBM Feedback property
The JMS_IBM_Feedback property identifies the type of report a message contains.
- Web Services Distributed Management in an administrative agent environment
Use Web Services Distributed Management (WSDM) to manage application server profiles in an administrative agent (AdminAgent) environment.
- Web Services Distributed Management in a stand-alone application server instance
In a stand-alone application server environment, there is one Web Services Distributed Management (WSDM) application deployed for each application server instance.
- Web Services Distributed Management in a WAS ND cell
Use Web Services Distributed Management (WSDM) to manage application server instances within a WAS ND cell. The administrative support and visibility for WSDM in a cell is obtained through interaction with each WSDM application deployed on the application server.
- Web Services Distributed Management manageability capabilities for WAS resource types
A resource that supports one or more manageability capabilities is a manageable resource. Each resource type exposed within the product supports a number of Web Services Distributed Management (WSDM) manageability capabilities.
- Web Services Distributed Management resource management
Web Services Distributed Management (WSDM) is an OASIS approved standard that supports the management of resources through a standardized web service interface. WSDM delivers web services based interfaces to manage application server resources using a manageability endpoint.
- Web Services Distributed Management support in the application server
The Web Services Distributed Management (WSDM) support for a Web service in WAS runs within an application server that has exposed management functions.
- Web services messages overview
To work with the data graph form of web services messages, we need to know the structure of the data graph, and how to develop code that can navigate the data graph.
- Web services performance best practices
Learn about best practices for the performance of web services applications.
- Web Services Security APIs
The Web Services Security programming model provides application programming interfaces (WSS API) for securing the SOAP message. The WSS API model is based on Web Services Security Version 1.1 standards but also includes support for Web Services Security Version 1.0.
- Web Services Security support
IBM supports Web Services Security, which is an extension of the IBM Web services engine, to provide a quality of service. The WAS security infrastructure fully integrates Web Services Security with the Java EE security specification.
- WebSphere extensions to the Enterprise JavaBeans specification
This topic outlines extensions to the Enterprise JavaBeans (EJB) specification provided with the product.
- IBM MQ naming restrictions
The naming restrictions for IBM MQ queues, queue managers, and queue-sharing groups are more restrictive than those that apply to equivalent objects in WAS. Use this information to help we administer the WAS objects, so that the names of these objects can be passed successfully to and from IBM MQ.
- WSGrid JCL template to use with JZOS Batch Toolkit for z/OS SDKs
The WSGrid job template is an input to the WSGrid utility. Use the WSGrid utility to submit a job to the batch scheduler that has an external interface configured to use the default messaging system. Use the template with JZOS Batch Toolkit for z/OS software development kits.
- WSGrid job template
The WSGrid job template is an input to the WSGrid utility. The template contains the properties that the WSGrid utility uses to interact with a batch job.
- WSIFOperation - Asynchronous interactions reference
The Web Services Invocation Framework (WSIF) supports asynchronous operation. In this mode of operation, the client puts the request message as part of one transaction, and carries on with the thread of execution. The response message is then handled by a different thread, with a separate transaction.
- WSIFOperation - Context
Although WSDL does not define context, a number of uses of the Web Services Invocation Framework (WSIF) require the ability to pass context to the port that is invoking the service.
- WSIFOperation interface
We use the WSIFOperation interface to invoke a service, based on a particular binding.
- WSIFOperation - Synchronous and asynchronous timeouts reference
When we use the Web Services Invocation Framework (WSIF) with the Java Message Service (JMS) we can set timeouts for synchronous and asynchronous operations.
- WSIFPort interface
The port implements a factory method for the WSIFOperation interface.
- WSIFServiceFactory class
To find a service from a Web Services Description Language (WSDL) document at a web address, or from a code-generated code base, we can use the WSIFServiceFactory class.
- WSIFService interface
The WSIFService interface can generate an instance of the WSIFOperation interface to use for a particular invocation of a service operation.
- WS-ReliableMessaging - administrative console panels
Links to topics that describe the contents of the administrative console panels we can use to configure and operate WS-ReliableMessaging. Each topic gives details of the purpose and use of a panel, the administrative console navigation path to the panel, and the values that we can set in each field of the panel.
- WS-Trust client API
The WS-Trust client API includes the WSSTrustClient class, the WSSTrustClientValidateResult class, and other configuration utility classes. The WSSTrustClient class provides helper functions that send WS-Trust SOAP requests to the specified external Security Token Service (STS) so that the STS can issue or validate one or more SAML assertions and other types of security tokens.