General Strategy

To override the default behavior for a pluggable component:

• Develop implementation of components interface
• Define the implementation class to Axis by either creating a service definition file (prefered) or by setting a system property.
  • PREFERED: To create a service definition file:
    • The name of the service definition file is derived from the interface or abstract class which the service implements/extends:
      /META-INF/services/<componentPackage>.<interfaceName>.
    • Put the fully qualified class name of the implementation class on a line by itself in the service definition file.
  • Set system property:
    • The name of the system property is the name of the interface.
    • The value of the system property is the name of the implementation.
    • The optional system property name (in table, below) may be also be used.
    • Setting a system property is not prefered, particularly in a J2EE or other application hosting environment, because it imposes a directive across all applications. This may or may not be appropriate behavior. If it is to be done, it should never be done from within a Web Application at runtime.
• Package the implementation class and, if used, the service definition file in a JAR file and/or place it where it can be picked up by a class loader (CLASSPATH).

Example 1

To override the default behavior for the Java Compiler:

• An implementation of the Compiler interface is already provided for the Jikes compiler.
• Create the service definition file named:
  /META-INF/services/org.apache.axis.components.compiler.Compiler
• Add the following line to the service definition file:
  org.apache.axis.components.compiler.Jikes
• Since org.apache.axis.components.compiler.Jikes is packaged with Axis, all that needs to be done is to ensure that the service definition file is loadable by a class loader.

Example 2

To override the default behavior for the SocketFactory in an environment that does not allow resources to be located/loaded appropriately, or where the behavior needs to be forced to a specific implementation:

• Provide an implementation of the SocketFactory interface, for example your.package.YourSocketFactory
• Set the system property named
  org.apache.axis.components.net.SocketFactory
  to the value
  your.package.YourSocketFactory
  
  This can be done by using the JVM commandline
  -Dorg.apache.axis.components.net.SocketFactory=your.package.YourSocketFactory
• Ensure that the implementation class is loadable by a class loader.

Reference

(Component/Package: org.apache.axis.components.*)

Justification/Rationale

A pluggable logging/trace facility enables Axis to direct logging/trace messages to a host web application server's logging facility. A central logging facility with a single point of configuration/control is superior to distinct logging mechanisms for each of a multitude of middleware components that are to be integrated into a web application server.

Integration

The minimum requirement to integrate with another logger is to provide an implementation of the org.apache.commons.logging.Log interface. In addition, an implementation of the org.apache.commons.logging.LogFactory interface can be provided to meet specific requirements for connecting to, or instantiating, a logger.

• org.apache.commons.logging.Log

  The Log interface defines the following methods for use in writing log/trace messages to the log:

    log.fatal(Object message);
    log.fatal(Object message, Throwable t);
    log.error(Object message);
    log.error(Object message, Throwable t);
    log.warn(Object message);
    log.warn(Object message, Throwable t);
    log.info(Object message);
    log.info(Object message, Throwable t);
    log.debug(Object message);
    log.debug(Object message, Throwable t);
    log.trace(Object message);
    log.trace(Object message, Throwable t);
  
    log.isFatalEnabled();
    log.isErrorEnabled();
    log.isWarnEnabled();
    log.isInfoEnabled();
    log.isDebugEnabled();
    log.isTraceEnabled();

  Semantics for these methods are such that it is expected that the severity of messages is ordered, from highest to lowest:

  • fatal - Consider logging to console and system log.
  • error - Consider logging to console and system log.
  • warn - Consider logging to console and system log.
  • info - Consider logging to console and system log.
  • debug - Log to system log, if enabled.
  • trace - Log to system log, if enabled.
• org.apache.commons.logging.LogFactory

  If desired, the default implementation of the org.apache.commons.logging.LogFactory interface can be overridden, allowing the JDK 1.3 Service Provider discovery process to locate and create a LogFactory specific to the needs of the application. Review the Javadoc for the LogFactoryImpl.java for details.

Mechanism

• Life cycle

  The JCL LogFactory implementation must assume responsibility for either connecting/disconnecting to a logging toolkit, or instantiating/initializing/destroying a logging toolkit.

• Exception handling

  The JCL Log interface doesn't specify any exceptions to be handled, the implementation must catch any exceptions.

• Multiple threads

  The JCL Log and LogFactory implementations must ensure that any synchronization required by the logging toolkit is met.

Logger Configuration

• Log

  The default LogFactory provided by JCL can be configured to instantiate a specific implementation of the org.apache.commons.logging.Log interface by setting the property org.apache.commons.logging.Log. This property can be specified as a system property, or in the commons-logging.properties file, which must exist in the CLASSPATH.

• Default logger if not plugged

  The Jakarta Commons Logging SPI uses the implementation of the org.apache.commons.logging.Log interface specified by the system property org.apache.commons.logging.Log. If the property is not specified or the class is not available then the JCL provides access to a default logging toolkit by searching the CLASSPATH for the following toolkits, in order of preference:

  • Log4J
  • JDK 1.4
  • JCL SimpleLog

Translation

• Justification/Rationale

  In order for readers of languages other than English to be comfortable with Axis, we provide a mechanism for the strings used in Axis to be translated. We do not provide any translations in Axis; we merely provide a means by which translators can easily plug in their translations.

• Mechanism

  Axis provides english messages in the Java resource named org.apache.axis.i18n.resource.properties (in the source tree, the file is named xml-axis/java/src/org/apache/axis/i18n/resource.properties).

  Axis makes use of the Java internationalization mechanism - i.e., a java.util.ResourceBundle backed by a properties file - and the java.text.MessageFormat class to substitute parameters into the message text.

  • java.util.ResourceBundle retrieves message text from a property file using a key provided by the program. Entries in a message resource file are of the form <key>=<message>.
  • java.text.MessageFormat substitutes variables for markers in the message text. Markers use the syntax "{X}" where X is the number of the variable, starting at 0.

  For example: myMsg00=My {0} is {1}.

  Translation requires creating an alternate version of the property file provided by Axis for a target language. The JavaDoc for java.utils.ResourceBundle provides details on how to identify different property files for different locales.

  For details on using Axis's internationalization tools, see the Developer's Guide.

• Default behavior

  The default behavior, meaning what happens when a translated file doesn't exist for a given locale, is to fall back on the English-language properties file. If that file doesn't exist (unlikely unless something is seriously wrong), Axis will throw an exception with an English-language reason message.

Extending Message Files

Axis provides a Message file extension mechanism that allows Axis-based code to use Axis message keys, as well as new message keys unique to the extended code.

• Justification/Rationale

  Axis provides pluggable interfaces for various Axis entities, including EngineConfigurationFactory's, Provides, and Handlers. Axis also provides a variety of implementations of these entities. It is convenient to use Axis source code for such implementations as starting points for developing extentions and customizations that fulfill the unique needs of the end user.

• Procedure

  To extend the Axis message file:

  • Copy the Axis source file java/src/org/apache/axis/i18n/Messages.java to your project/package, say my/project/package/path/Messages.java.
    • Set the package declaration in the copied file to the correct package name.
    • Set the private attribute projectName to "my.project": the portion of the package name that is common to your project. projectName must be equal to or be a prefix of the copied Messages package name.
  • Create the file my/project/package/path/resource.properties. Add new message key/value pairs to this file.
  • As you copy Axis source files over to your project, change the import org.apache.axis.i18n.Messages statement to import my.project.package.path.Messages.
  • Use the methods provided by the class Messages, as discussed in the Developer's Guide, to access the new messages.
• Behavior
  • Local Search

    Messages begins looking for a key's value in the resources.properties resource in it's (Messages) package.

  • Hierarchical Search

    If Messages cannot locate either the key, or the resource file, it walks up the package hierarchy until it finds it. The top of the hierarchy, above which it will not search, is defined by the projectName attribute, set above.

  • Default behavior

    If the key cannot be found in the package hierarchy then a default resource is used. The default behaviour is determined by the parent attribute of the Messages class copied to your extensions directory.

    Unless changed, the default behavior, meaning what happens when a key isn't defined in the new properties file, is to fall back to the Axis properties file (org.apache.axis.i18n.resource.properties).

Symbol Table

The symbol table, found in org.apache.axis.wsdl.symbolTable, will contain all the symbols from a WSDL document, both the symbols from the WSDL constructs themselves (portType, binding, etc), and also the XML schema types that the WSDL refers to.

NOTE: Needs lots of description here.

The symbol table is not extensible, but you can add fields to it by using the Dynamic Variables construct:

• You must have some constant object for a dynamic variable key. For example: public static final String MY_KEY = "my key";
• You set the value of the variable in your GeneratorFactory.generatorPass: entry.setDynamicVar(MY_KEY, myValue);
• You get the value of the variable in your generators: Object myValue = entry.getDynamicVar(MY_KEY);

Parser Front End and Generator Framework

The parser front end and generator framework is located in org.apache.axis.wsdl.gen. The parser front end consists of two files:

• Parser

  public class Parser {
    public Parser();
    public boolean isDebug();
    public void setDebug(boolean);
    public boolean isImports();
    public void setImports(boolean);
    public boolean isVerbose();
    public void setVerbose(boolean);
    public long getTimeout();
    public void setTimeout(long);
    public java.lang.String getUsername();
    public void setUsername(java.lang.String);
    public java.lang.String getPassword();
    public void setPassword(java.lang.String);
    public GeneratorFactory getFactory();
    public void setFactory(GeneratorFactory);
    public org.apache.axis.wsdl.symbolTable.SymbolTable getSymbolTable();
    public javax.wsdl.Definition getCurrentDefinition();
    public java.lang.String getWSDLURI();
    public void run(String wsdl) throws java.lang.Exception;
    public void run(String context, org.w3c.dom.Document wsdlDoc)
      throws java.io.IOException, javax.wsdl.WSDLException;
  }

  The basic behavior of this class is simple: you instantiate a Parser, then you run it.

  Parser parser = new Parser();
  parser.run("myfile.wsdl");

  There are various options on the parser that have accessor methods:

  • debug - default is false - dump the symbol table after the WSDL file has been parsed
  • imports - default is true - should imported files be visited?
  • verbose - default is false - list each file as it is being parsed
  • timeout - default is 45 - the number of seconds to wait before halting the parse
  • username - no default - needed for protected URI's
  • password - no default - needed for protected URI's

  Other miscellaneous methods on the parser:

  • get/setFactory - get or set the GeneratorFactory on this parser - see below for details. The default generator factory is NoopFactory, which generates nothing.
  • getSymbolTable - once a run method is called, the symbol table will be populated and can get queried.
  • getCurrentDefinition - once a run method is called, the parser will contain a Definition object which represents the given wsdl file. Definition is a WSDL4J object.
  • getWSDLURI - once the run method which takes a string is called, the parser will contain the string representing the location of the WSDL file. Note that the other run method - run(String context, Document wsdlDoc) - does not provide a location for the wsdl file. If this run method is used, getWSDLURI will be null.
  • There are two run methods. The first, as shown above, takes a URI string which represents the location of the WSDL file. If you've already parsed the WSDL file into an XML Document, then you can use the second run method, which takes a context and the WSDL Document.

  An extension of this class would ...

  NOTE: continue this sentiment...

• WSDL2

  Parser is the programmatic interface into the WSDL parser. WSDL2 is the command line tool for the parser. It provides an extensible framework for calling the Parser from the command line. It is named WSDL2 because extensions of it will likely begin with WSDL2: WSDL2Java, WSDL2Lisp, WSDL2XXX.

  public class WSDL2 {
    protected WSDL2();
    protected Parser createParser();
    protected Parser getParser();
    protected void addOptions(org.apache.axis.utils.CLOptionDescriptor[]);
    protected void parseOption(org.apache.axis.utils.CLOption);
    protected void validateOptions();
    protected void printUsage();
    protected void run(String[]);
    public static void main(String[]);
  }

  Like all good command line tools, it has a main method. Unlike some command line tools, however, its methods are not static. Static methods are not extensible. WSDL2's main method constructs an instance of itself and calls methods on that instance rather than calling static methods. These methods follow a behavior pattern. The main method is very simple:

  public static void main(String[] args) {
    WSDL2 wsdl2 = new WSDL2();
    wsdl2.run(args);
  }

  The constructor calls createParser to construct a Parser or an extension of Parser.

  run calls:

  • parseOption to parse each command line option and call the appropriate Parser accessor. For example, when this method parses --verbose, it calls parser.setVerbose(true)
  • validateOptions to make sure all the option values are consistent
  • printUsage if the usage of the tool is in error
  • parser.run(args);

  If an extension has additional options, then it is expected to call addOptions before calling run. So extensions will call, as necessary, getParser, addOptions, run. Extensions will override, as necessary, createParser, parseOption, validateOptions, printUsage.

  The generator framework consists of 2 files:

  • Generator

    The Generator interface is very simple. It just defines a generate method.

    public interface Generator
    {
      public void generate() throws java.io.IOException;
    }

  • GeneratorFactory

    public interface GeneratorFactory
    {
      public void generatorPass(javax.wsdl.Definition, SymbolTable);
      public Generator getGenerator(javax.wsdl.Message, SymbolTable);
      public Generator getGenerator(javax.wsdl.PortType, SymbolTable);
      public Generator getGenerator(javax.wsdl.Binding, SymbolTable);
      public Generator getGenerator(javax.wsdl.Service, SymbolTable);
      public Generator getGenerator(TypeEntry, SymbolTable);
      public Generator getGenerator(javax.wsdl.Definition, SymbolTable);
      public void setBaseTypeMapping(BaseTypeMapping);
      public BaseTypeMapping getBaseTypeMapping();
    }

    The GeneratorFactory interface defines a set of methods that the parser uses to get generators. There should be a generator for each of the WSDL constructs (message, portType, etc - note that these depend on the WSDL4J classes: javax.xml.Message, javax.xml.PortType, etc); a generator for schema types; and a generator for the WSDL Definition itself. This last generator is used to generate anything that doesn't fit into the previous categories.

    In addition to the getGeneratorMethods, the GeneratorFactory defines a generatorPass method which provides the factory implementation a chance to walk through the symbol table to do any preprocessing before the actual generation begins.

    Accessors for the base type mapping are also defined. These are used to translate QNames to base types in the given target mapping.

  In addition to Parser, WSDL2, Generator, and GeneratorFactory, the org.apache.axis.wsdl.gen package also contains a couple of no-op classes: NoopGenerator and NoopFactory. NoopGenerator is a convenience class for extensions that do not need to generate artifacts for every WSDL construct. For example, WSDL2Java does not generate anything for messages, therefore its factory's getGenerator(Message, SymbolTable) method returns an instance of NoopGenerator. NoopFactory returns a NoopGenerator for all getGenerator methods. The default factory for Parser is the NoopFactory.

Code Generator Back End

The meat of the WSDL2Java back end generators is in org.apache.axis.wsdl.toJava. Emitter extends Parser. org.apache.axis.wsdl.WSDL2Java extends WSDL2. JavaGeneratorFactory implements GeneratorFactory. And the various JavaXXXWriter classes implement the Generator interface.

NOTE: Need lots more description here...

WSDL Framework Extension Examples

Everything above sounds rather complex. It is, but that doesn't mean your extension has to be.