All Classes and Interfaces
Class
Description
Custom WSDL locator to load schemas from zip archives
Need to provide the aarFile and the baseInputStream for
the base WSDL file
A custom URI resolver that can
This is the top most level of the Context hierarchy and is a bag of properties.
AbstractDeployer class which can be extended by all Axis2 deployers
This the base class for all dispatchers.
Class AbstractHandler
This is the Absract IN-OUT MEP MessageReceiver.
The Class AbstractServiceBuilderExtension is abstract class that can be used
to write new ServiceBuilderExtensions.
This abstract class differentiates the concern of the conditional check to see whether this
particular message needs to be handled by the handler implementation and the actual invocation
logic.
This utility wrapper class is created to support AXIS2 runs
inside of Java 2 Security environment.
Some Externalize objects must be "activated" after they are read.
Dispatcher based on the WS-Addressing properties.
Interface AddressingConstants
This builder is used when the serialization of the message is application/xml.
Formates the request message as application/xml
An implementation of the
Stack API that is based on an ArrayList
instead of a Vector, so it is not synchronized to protect against multi-threaded
access.An AxisBinding represents a WSDL binding, and contains AxisBindingOperations.
An AxisBindingOperation represents a WSDL <bindingOperation>
Class AxisConfiguration
AxisDataLocator interface defines getData API for retrieving data particularly
metadata like WSDL, Policy, Schema.
The Default Axis2 Data Locator implementation
There is one engine for the Server and the Client. the send() and receive()
Methods are the basic operations the Sync, Async messageing are build on top.
An exception which maps cleanly to a SOAP fault.
This class represents the messages in WSDL.
This holds the information about a Module.
This class provide a very convenient way of creating server and deploying services.
Class AxisService
BaseAxisDataLocator implements common code and serves as a base class
for the supported default Axis2 dialect data locators.
this class is used to keep the excludeProperties and includePropertes
of the given bean when generating the wsdl, and serializing.
BeanInfo cache that stores introspection results by bean class and stop class.Interface implemented by class loaders that keep a
BeanInfo cache.Message builder able to convert a byte stream into a SOAP infoset.
This is a MessageReceiver which is used on the client side to accept the
messages (response) that come to the client.
Description: In ParamReader class, user cannot get inherited method parameter
from the class they passed in for performance reasons This class
is walks up the inheritance chain.
This is the class file reader for obtaining the parameter names
for declared methods in a class.
Utility methods for various clients to use.
Builds the cluster configuration from the axis2.xml file
This is the main interface in the Axis2 clustering implementation.
All constants used by the Axis2 clustering implementation
The main cluster configuration parameters
This is a special ClusteringCommand which is used for messaging.
Deprecated.
Axis2 states are held in two information models, called description hierarchy and context
hierarchy.
Class Constants
A ContextListener gets informed about new context creations & removal of existing contexts.
This class provides a simple zero-based counter with synchronized access.
Data contains instance of the data Object for the specified identifier if applicable.
Factory to constructor Axis2 Data Locators based on the specified
Dialect.
Exception class for reporting Data Retrieval problems
Allow to specify options/parameters for getData request.
DebugObjectInput delegates to an ObjectInput object.
DebugObjectOutputStream delegates to an ObjectOutput object.
This class provides the default implementatoin for mapping java classes to namespaces
This is a simple ThreadFactory implementation using java.util.concurrent
Creates threads with the given name prefix
If the service implementation has an init method with 1 or 2 message context as its parameters, then
the DependencyManager calls the init method with appropriate parameters.
A Deployable is a container for something (Phases, Handlers) which wants
to be deployed in an ordered and constrained fashion via a
DeployableChain.
A DeployableChain is a container which manages dependencies between Deployables.
This interface is used to provide the custom deployment mechanism , where you
can write your own Deployer to process a particular type and make that to
a service or a module.
Constants used during service/module deployment.
DeploymentFileData represents a "thing to deploy" in Axis2.
this interface is used to inform deployment lifecycle realated events to
listners
This class does the common tasks for all *Builder class.
Defines constants referenced in data retrieval classes.
Defines contants references in Service Data
Defines contants references in WS-Mex specification
Class EndpointReference
This class models the WS-A EndpointReferenceType.
The methods in this class are used to process
EndpointReference objects
according to the rules of the 2005/08 (Final) and 2004/08 (submission) WS-Addressing
specifications.this class is used to keep the exclude property details of all the classes.
Common Externalize Constants
this class is intended to use as the key for fault maps used
in generated stubs.
Class FlowImpl
Class FlowIncludeImpl
This is the interface through which the load balancing event are notified.
A Handler represents a piece of message processing functionality in Axis2.
This type encapsulates an enumeration of possible message processing
instruction values that may be returned by a handler/phase within the
runtime.
Represents the deployment information about the handler
HTTP protocol and message context constants.
Dispatches the operation based on the information from the target endpoint URL.
JavaUtils
Dispatches based on JSON requests by using the first name of
the message.
The Lifecycle interface should be implemented by your back-end service
class if you wish to be notified of creation and cleanup by the Axis2
framework.
Loads resources (or images) from various sources.
Defines Data Locator types as described below:
DEFAULT_AXIS - Default Axis2 data locator
GLOBAL_LEVEL - Global level data locator i.e.,plug-in data locator registered
using element in axis2.xml.
This class provides a more efficient means of control over logging than
do most providers of the Common's logging API at the cost of runtime
flexibility.
Writer implementation that redirects to a logger.Represents a member in the cluster.
This is the interface which will be notified when memership changes.
Accept parameters for ProjectResourceBundle,
but defer object instantiation (and therefore
resource bundle loading) until required.
Axis2 states are held in two information models, called description hierarchy
and context hierarchy.
A MessageContextListener is registered on the AxisService.
Utility to read/write the Message of a MessageContext
Message Object Format.
MessageFormatter implementations are used by Axis2 to support serialization
of messages to different message formats.
MessageProcessorSelector is utility class which encapsulate MessageBuilder and
MessageFormatter selection logic.
An instance of MessageReceiver can be setup to receive messages.
An internal class for holding a set of information
about an object.
Extension interface for
Builder implementations that can build a message from a MIME
multipart message.Every module provides an implementation of this class.
Builds a module description from OM
This is to store deployment time data , described by
....
Standard Axis2 Module Deployer which use module.xml file to deploy
Modules.
A MultiParentClassLoader is a simple extension of the URLClassLoader that simply changes the single parent class
loader model to support a list of parent class loaders.
Formates the request message as multipart/form-data.
This will make a hash map which can contain multiple entries for the same hash value.
This interface must be implemented to provide custom implemtations for,
java package name to namespace mapping.
This class represents the 2-phase commit protocol, where an event is processed,
the system is prepared to switch to a new configuration based on the processed event,
and finally commits the new configuration (i.e. the system switches to the new configuration).
This interface is responsible for handling configuration management.
An ObjectInputStream that is constructed with a ClassLoader or ClassResolver.
This interface is used to resolve OSGi declared serializable classes.
Utility to write, read and activate externalized Objects
The OnDemandLogger will defer the creation of the
actual Log object until it is needed.
An operation client is the way an advanced user interacts with Axis2.
An OperationContext represents a running "instance" of an operation, which is
represented by an AxisOperation object.
This is the factory for OperationContext.
Holder for operation client options.
An interface for the options validator.
Class Parameter
Interface ParameterInclude
Class ParameterIncludeImpl
This class retrieves function parameter names from bytecode built with
debugging symbols.
This is the class file reader for obtaining the parameter names
for declared methods in a class.
A Phase is an ordered collection of Handlers.
Class PhaseException
This class hold all the phases found in the services.xml and server.xml
Class PhaseMetadata
Class PhaseResolver
Class PhaseRule
Axis 2 Data Locator responsibles for retrieving Policy metadata.
Wrapper class for resource bundles.
This class holds the difference between two properties which are stored in the
AbstractContext
Parser for URL query strings.
The RawXMLINOnlyMessageReceiver MessageReceiver hands over the raw request received to
the service implementation class as an OMElement.
The RawXMLINOutMessageReceiver MessageReceiver hands over the raw request received to
the service implementation class as an OMElement.
CURRENTLY NOT USED
KEEPING FOR REFERENCE 9/19/2002
Class RelatesTo
Replicates serializable properties
This interface represents a control object for a Request/Response transport.
Used to give the current status of the RequestResponseTransport object.
Dispatches the service based on the information from the target endpoint URL.
Dispatches the operation based on the information from the target endpoint URL.
Dispatches the operation based on the information from the target endpoint URL.
A SafeObjectInputStream reads data that was written by SafeObjectOutputStream
A SafeObjectOutputStream provides extra mechanisms to ensure that
objects can be safely serialized to the ObjectOutput.
This is a marker interface that indicates that the Object
and all contents of the Object can be serialized safely without
buffering.
Axis 2 Data Locator responsibles for retrieving Schema metadata.
Return a XMLSchema as an OMElement.
An interface for use by a message handler to allow
it to save and restore any message-specific data.
Builds a service description from OM
The interface ServiceBuilderExtension provides an extension point to
org.apache.axis2.deployment.Deployer interface.
Client access to a service.
Well this is never clearly defined, what it does or the life-cycle.
This represents the service data for a dialect and identifier if specified.
Standard Axis2 service Deployer which use services.xml file to build
services.
When you want to initialize database connections , starting threads and etc..
All the engine components are stateless across the executions and all the states should be kept in the
Contexts, there are three context Global, Session and Message.
Dispatches based on the SOAPAction.
Dispatches based on the namespace URI of the first child of
the body.
This interface is responsible for handling context replication.
Base class for generated client stubs.
TargetResolver
Generates and properly cleans up temporary files.
This is the interface for a piece of code that will plug into the user
programming model impl (e.g.
This is a utility class to make it easier/cleaner for user programming
model-level implementations (e.g. the Axis2 JAX-WS code) to invoke the
ThreadContextMigrators.
This the thread pool for axis2.
Represents an incoming transport deployed in Axis2.
Class TransportListener
Represents a transport deployed in AXis2
TransportSender sends the SOAP Message to other SOAP nodes.
Normally when we connect over HTTPS, if the server sends us a certificate that is not well
known, we have to specify a keystore using system properties:
This class is to keep common methods and properties in InOut and OutIn axisOperation
This util is used on the client side for creating the URL's for all request (WSDL 2.0 allws to
change the URL's of SOAP messages too).
Class representing a version number and implementing a comparison algorithm compatible
with Maven.
Little utility to get the version and build date of the axis2.jar.
Processes the init parameters for the AxisServlet.
This class acts as a wrapper for the jakarta.activation.DataHandler class.
The WSDL11ActionHelper provides 3 static methods to determine the correct wsa:Action value from
a wsdl4j Input/Output/Fault object.
Generates a wsa:Action value using the Default Action Pattern defined at
http://www.w3.org/TR/2006/WD-ws-addr-wsdl-20060216/#defactionwsdl11
Extends the WSDL11ToAxisServiceBuilder class to provide functionality to return
multiple AxisService objects; one for each port on each service in the WSDL 1.1 file.
Inner class declaration for the processing exceptions
Extends the WSDL20ToAxisServiceBuilder class to provide functionality to return
multiple AxisService objects; one for each endpoint on each service in the WSDL 2.0 file.
This class provides support for processing a WSDL4J defintion which includes imports.
Axis 2 Data Locator responsibles for retrieving WSDL metadata.
There are cases where a WSDL definition is kept in memory
in case it needs to be accessed during runtime.
Helps the AxisService to WSDL process
The class WSDLServiceBuilderExtension is a ServiceBuilderExtension which
facilitate to generate AxisServices based on WSDL 1.1 and WSDL 2.0 documents.
Return a WSDL as an OMElement.
Some utility methods for the WSDL users
This class provides support for processing a WSDL4J definition
with a lower memory footprint.
This interface provides support for processing a WSDL4J definition
with a lower memory footprint.
This class provides support for processing a WSDL4J definition
with a lower memory footprint.
There are cases where a WSDL definition is kept in memory
in case it needs to be accessed during runtime.
Formates the request message as application/x-www-form-urlencoded
This class defines the basic XML character properties.
An XML pretty printer based on xsl stylesheets