HISTORY OF AXIS IBM contributes the early implementation of SOAP protocol to Apache in 1999, called Apache SOAP. Apache SOAP 1.2, 2.1,3.0 refactoring and redesigning codebase. Axis stands for Apache eXtensible Interaction System. The main architectural idea behind Axis is that of chains of message-processing components, that can be deployed separately and assembled at deployment time. These components are called handlers can each process portions of the message. Axis switch from SOAP's DOM-based XML processing to SAX system. JAX-RPC,JAXM/SAAJ and JAXB JSR Java Specification Request: JAXM XML messaging for Java: define javax.xml.soap package contains API for manipulating SOAP data structures. JAX-RPC XML based RPC for java: define standard API for implementing RPC-style Web services in Java. JAXB Java APIs for XML data-binding Installing Axis http://ws.apache.org/axis In Axis installation, copy axis dir to your servlet engine's webapps(tomcat) depend on particular servlet engine Verify lib of Axis on your classpath These include axis.jar commons-discovery.jar commons-logging.jar log4j-1.2.8.jar wsdl4j.jar jaxrpc.jar saaj.jar To use Axis client software, must have all jars above in lib AXIS ARCHITECTURE Axis is all about the chain of message processing components to work together to handle SOAP message. These components are called handlers. And these handlers are java classes. And these java classes are based on a simple interface:
Transcript
HISTORY OF AXIS IBM contributes the early implementation of SOAP protocol to Apache in 1999, called Apache SOAP. Apache SOAP 1.2, 2.1,3.0 refactoring and redesigning codebase. Axis stands for Apache eXtensible Interaction System. The main architectural idea behind Axis is that of chains of message-processing components, that can be deployed separately and assembled at deployment time. These components are called handlers can each process portions of the message. Axis switch from SOAP's DOM-based XML processing to SAX system. JAX-RPC,JAXM/SAAJ and JAXB JSR Java Specification Request: JAXM XML messaging for Java: define javax.xml.soap package contains API for manipulating SOAP data structures. JAX-RPC XML based RPC for java: define standard API for implementing RPC-style Web services in Java. JAXB Java APIs for XML data-binding Installing Axis http://ws.apache.org/axis In Axis installation, copy axis dir to your servlet engine's webapps(tomcat) depend on particular servlet engine Verify lib of Axis on your classpath These include axis.jar commons-discovery.jar commons-logging.jar log4j-1.2.8.jar wsdl4j.jar jaxrpc.jar saaj.jar To use Axis client software, must have all jars above in lib AXIS ARCHITECTURE Axis is all about the chain of message processing components to work together to handle SOAP message. These components are called handlers. And these handlers are java classes. And these java classes are based on a simple interface:
void invoke(MessageContext context) throws AxisFault; This method is from the org.apache.axis.Handler interface. That is the central thing that handlers must implement. When invoked, handler does what it is built to do. Examples: -reading or writing pieces of SOAP message. -logging information to database -check user's authentication credentials Some built-in method comes with Axis: authentication, session management, third parties.
More central than invoke() is MessageContext. This class represents all info relevant to SOAP interaction: request message, response message, properties to view and control system behaviours. Handlers are combined into chains to accomplish a task. Two types of chain: 1.Simple is a list of handlers that is invoked in order. 2.Targeted has exactly three handlers: request handler, pivot handler, response handler.
SERVER-SIDE MESSAGE PROCESSING Message flow on the server-side through Axis Use Axis as a SOAP server Transport listener receives a message. This might be a servlet, a JMS listener, or a class to poll a directory for new files in which you find SOAP messages. A built-in HTTP listener, a servlet org.apache.transport.http.AxisServlet This class accepts an HTTP request, wraps it in Axis Message class and then puts that Message into a MessageContext and hands it to an AxisServer,Which is the main server-side processing class. Beside message itself, MessageContext has loaded up with properties useful: time of message and format header. Listener might have a transport name compiled into code or get the name from a configuration parameter. Transport name allows to configure different kinds of functionality for different endpoint addresses.
TRANSPORT-SPECIFIC MESSAGE PROCESSING AxisServer first looks for a transport chain whose name matches the transport name in the MessageContext. If found, it hands MessageContext to the request handler of that chain. Ex: HTTP has a built-in authentication mechanism to pass username and password in a HTTP headers. Other transport protocols pass u/p in a SOAP header, which is not transport specific. GLOBAL MESSAGE PROCESSING After transport-specific request processing completes without error, the server passes MessageContext on to the Global request chain, which process every message into the system. SERVICE MESSAGE PROCESSING After the global message processing is finished, the server calls a service handler that process the message by looking at the endpoint URL or content inside message. Service handler is SOAPService(org.apache.axis.handlers.soap.SOAPService. This class is a targeted chain with request and response chain inside it. Inside SOAPService handler is a handler called provider that calls your service class. Use type mapping system to translate the incoming XML data into java objects and then again translate java objects in the response back into XML. THE PROVIDER
is pivot handler. the point to finish processing request message, continue with response message. MessageContext covered with response message from service, pass back through response chain, then global response chain, and finally transport-specific response chain. Afer message out of Axis server, HTTP listener (servlet) take the response message out of the MessageContext and sends it back to the client as HTTP response. On the way out of the system, there are chances for handlers to insert session management header or encrypt the outgoing body. CLIENT-SIDE MESSAGE PROCESSING Similar to AxisServer class, AxisClient class(org.apache.axis.client.AxisClient) handles messages flow through components on client. Call (org.apache.axis.client.Call)object is the main entry point to Axis. Always use Call to invoke the AxisClient. Or use a custom-built stub. AxisClient move MessageContext through processing flow, u never call it directly.
Like Fig 5.4, but the order of transport/global/service is reversed. On server side, transport chain does not have the pivot handler. On client side, transport chain has pivot handler, which is transport sender, that take request message out of MessageContext and send it. Then it retrieve response message from provider on server side and let response back through response chains. transport , then global, then service.
Call object gains control and get results back to your application code. MESSAGECONTEXT AND ITS MANY USES is a central piece of Axis architecture. takes the value out of SOAP header and put it in MessageContext property then this value can be retrieved.
Fig 5.7 Handler collaboration via the MessageContext THE MESSAGE APIs and SAAJ/A MESSAGE BY ANY OTHER NAME ask MessageContext for the request or response message, get back an object of type org.apache.axis.Message this class extends and make concrete the abstract SOAPMessage class from SAAJ. Two things in message are: a SOAPPart zero or more AttachmentParts Messages conforming to the simple SOAPHTTP binding will have only a SOAPPart and no attachments. SOAPPart gives you access to the SOAP envelope associated with the message. AttachmentPart let you access an abstract attachment by DataHandler object in Java Activation Framework.
Fig 5.8 THE SOAP message classes MessageElement -All the SOAP element classes in Axis inherit from org.apache.axis.message.MessageElement as an ancestor. -MessageElement implements SAAJ SOAPElement interface. -allow to access contents of elements in xml: child elements, attribute values -allow to ask for representation of deserialized element content. SOAPEnvelope --represents <soapenv:Envelope> -contains exactly one SOAPBody and zero or one SOAPHeaders. -Axis version provides convenience methods that avoid having to deal with the SOAPBody and SOAPHeader elements directly. -so add a body element direclty to a SOAPEnvelope with envelope.addBodyElement(bodyE1). SOAPBody -this class represents <soap:Body> element -is a container for SOAPBodyElements SOAPBodyElement -represent RPC calls and SOAP faults SOAPHeader -this class represents <soap:Header> element -is a container for SOAPHeaderElements. SOAPHeaderElement -provides all API to read, write SOAP header attributes: mustUnderstand and actor/role. -has a processed flag which processed by setProcessed(boolean) -if your method process headers, call setProcessed(true) on them
SOAPFault -this class extends SOAPBodyElement -represents SOAP fault -accessors to common fields: faultString, faultCode Use a piece of code to demo the message API usage. Purpose: print how many headers in the message, whether a header is present, whether a SOAP body contains a fault: void invoke(MessageContext context) throws AxisFault{ //Get SOAP envelope from the request message in the context Message requestMsg = context.getRequestMessage(); SOAPEnvelope env = requestMsg.getSOAPEnvelope(); //Count the headers in the message Vector headers = env.getHeaders(); System.out.println("There are " + headers.size() + " headers"); //Check whether a header is present SOAPHeaderElement header = env.getHeaderByName("http://example", "expiration"); if(header != null) System.out.println("Expiration header found."); //Does a SOAP body contain a fault SOAPBodyElement body = env.getFirstBody(); if(body instanceOf SOAPFault){ System.out.println("First body element is a fault, code=" + ((SOAPFault)body).getFaultCode().toString()); } } Note: These classes implement DOM element APIs and SOAP APIs. take a SOAPEnvelope object and feed it into DOM-based tools such as an XSLT engine to get at the data. ACCESSING THE SOAP ENVELOPE, BODIES AND HEADERS Fig 5.8 THE AXIS CLIENT APIs The SERVICE OBJECT org.apache.axis.client.Service acts as a factory for Call objects. store useful meta-data store AxisClient instance that processes your invocations lives. also where type mapping for XML <-> java binding are stored. one single call object represents a single invocation of a service.
JAX-RPC expects Service objects to come from somewhere in the system as JNDI preconfigured with WSDL. The Axis Service object has two constructors for you to access WSDL documents. Service(URL wsdlLocation, QName serviceName) This constructor builds you a service object with meta-data initialized from WSDL at the specified URL The second argument is the service QName from WSDL Service(String wsdlLocation,QName serviceName) This constructor has string that may be URL or a filename on the local filesystem, relative to the current directory. Using Call Object for dynamic invocation The Service object is the standard JAX-RPC way to get Call objects using the createCall() method. import org.apache.axis.client.Service; import javax.xml.rpc.Call; ... Service service= new Service(); Call call = service.createCall(); call.setTargetEndpointAddress(url); No argument Service constructor, create a blank service no arguments in createFactory() , create a generic JAX-RPC Call object. returns a javax.xml.rpc.Call Since we are using AXIS, we know it really an org.apache.axis.client.Call If need to use any of Axis specific methods, downcast it to Axis type. Pass endpoint URL of target Web service to the newly created Call object. Axis also provides some direct constructors to create a Call object. Call(String endPoint) Call(URL endpoint) These methods are convenient to avoid the need to use a Service object directly. INVOKING A WEB SERVICE Call object is used to invoke a Web service. invoke() method is passed into a Java array of objects. These objects are parameters for a remote method call and each one
maps to an XML element inside a wrapper method call element. TAKING CONTROL OF PARAMETERS use addParameters() on Call objects to serialize in some ways instead of default way. let u control parameters type, mode Some different signatures of addParameters(), basic one is: addParameters(String paramName, QName xmlType, ParameterMode paramMode) paraName: QName instead of a String if you use document-style sevices and need control namespaces of parameter elements. xmlType: QName represent XML schema type of parameter. paraMode: in, out or inout ( constants of class javax.xml.rpc.ParameterMode) Example: 1.set call object Call call= new Call(url); 2. Use SOAP 1.2 call.setSOAPVersion(SOAPConstants.SOAP12_CONSTANTS); 3.control parameter types addParameter("SKU",org.apache.axis.Constants.XSD_STRING,ParameterMode.IN); addParameter("quantity",org.apache.axis.Constants.XSD_INT,ParameterMode.IN); 4.set up parameters for invocation Object[] params = new Object[] {"SKU-56",new Integer(56)}; 5.call it Boolean result = (Boolean)call.invoke(" ", "doCheck", params); SOAP message will change like this <soapenv:Body> <doCheck> <SKU xsi:type="xsd:string">SKU-56</SKU> <quantity:type="xsd:int">56</quantity> </doCheck> </soapenv:Body> USING other Call object with a WSDL-Enabled Service APIs for creating Calls: 1.service.createCall(QName portName) This returns a Call that has been initialized with the endpoint address referred to by the named port in WSDL. No metadata set. 2.service.createCall(QName portName, QName operation) This only sets endpoint address but also all parameters and return types preconfigured for the operation.
Note: if you call addParameter(), setReturnType() on Call object, you get an Exception because the configuration is already set. 3.service.createCall(QName portName, String operation) like previous one but accepts unqualified operation name from the WSDL rather than a full QName TYPE MAPPING USING THE CALL A type mapping consists of an XML type(QName), a Java type(class), a serializer(to write Java to XML) and a deserializer(to write Java from XML). Call object's registerTypeMapping API(this is axis-specific, not for JAX-RPC) call.registerTypeMapping(Class javaType, QName xmlType, Class serivalizerFactoryClass,Class deserializerFactoryClass) If u have a javabean class that represents Product, u can tell axis how to serialize that type as xml by using default bean serializer and deserializer. call.registerTypeMapping(Product.class, new QName("http://skatestown.com","Product"), BeanSerializerFactory.class,BeanDeserializerFactory.class) SETTING PROPERTIES ON THE CALL call.setProperty(String name, Ojbect value) All properties you set on Call will be available to every MessageContext that is created as a result of using that Call. Server and property scoping Important thing: Use a Call object to make many invocations to a service. Each time a new MessageContext is created, all handlers in that invocation will have access not only to the MessageContext properties, but also the ones you set on the Call thatpersist across invocation. USING SESSIONS client calls services that perform the same functions the way regardless of who calls them. Example: getStockQuote() Important the server remembers who you are, when you call services. Session is used to associcate a set of data to the client by the server. Axis has some APIs to support session in the pluggable fashion. U use underlying session supplied by application servers to custom sessions implemented as SOAP extensions. Axis has two ways to maintain sessions across Web service connections.
1. Use HTTP session mechanism built in to any servlet engine, use HTTP cookies to store session state and actual session data that is kept by the servlet framework. Need to use HTTP transport by default. Must call setMaintainSession(true) on the Call or Service. 2. Use custom implementation to store session data and passes session identifiers via SOAP headers. Need to deploy the SimpleSessionHandler(org.apache.axis.handlers.SimpleSessionHandler included in Axis) by using Web service deployment descriptor(WSDD) see chapter 8. USING STUBS and WSDL2JAVA 2 tools of Axis WSDL2Java generates Java code from WSDL description, create client stub to call service and server-side implementation scaffolding to build your own implementation. Java2WSDL is a command line tool for taking Java interface and generating WSDL At runtime, Axis engine automatically generate WSDL for deployed services. STUBS A stub is a Java class with a Java API that matches the Web service interface defined in a WSDL document. Example: Build a stub from WSDL for the InventoryCheck Service. USING GENERATED STUB GENERATING TEST CASES HOLDERS: MAPPING INOUT/OUT parameters to Java Automatic type mapping with WSDL2Java WEB SERVICE DEPLOYMENT DESCRIPTOR(WSDD) HANDLER DECLARATIONS CHAIN DEFINTIONS can put many handlers together into a chain and give it a name. That name can be used as a type. Example: <chain name="logAndNotify"> <!-- This chain logs the message, then also sends an email --> <handler type="java.org.apache.axis.handlers.LogHandler"/>
<handler type="java:myPackage.NotificationHandler"> <parameter name="email" value="[email protected]"/> </chain> PUt it in a request flow: <requestFlow> <handler type="logAndNotify"/> ....more declarations </requestFlow> Note: can parameterize inside a chain as ex above put email to send TRANSPORT define a named chain which has a request flow, a response flow and a pivot handler. is an outgoing concept pivot is the sender of the message. Example: a client transport in default client-config.wsdd file <transport name="http" pivot="java:org.apache.axis.transport.http.HTTPSender"/> Define a pivot handler for a transport with attribute pivot. On the server, http transport declaration like this: <handler type="java:org.apache.axis.handlers.http.URLMapper" name="URLMapper"/> <transport name="http"> <requestFlow> <handler type="URLMapper"/> <handler type="java:org.apache.axis.handlers.http.HTTPAuthHandler"/> </requestFlow> </transport> Note: The handler URLMapper sets Axis service name in MessageContext based on the HTTP URL. So when u access http://host:8080/axis/services/POSubmission Axis will end up looking for a deployed service named POSubmission. The other takes username and password out of an http authentication header and puts them in the MessageContext in a transport form. TYPE MAPPINGS <beanMapping> is abre for <typeMapping> uses BeanSerializer/BeanDeserializer classes in package org.apache.axis.encoding.ser to do default data-mapping algorithms. example: <beanMapping qname="type QName" languageSpecificType="java:classname" encodingStyle="url"/> Like registerTypeMapping() attribute encodingStyle is optional.
If use empty string instead of encodingStyle specified, the type mapping will work for all encoding styles(literal, or unencoded) <typeMapping qname="typeQName", type="java:classname", serializer="Serializer" deserializer="DeserializerFactory" encodingStyle="uri"/> How Axis is architected How to use client-side API to call services How to use WSDD to deploy components: handler and transport How to deploy ur Web services using Axis framework. BUILDING SERVICES INSTANT DEPLOYMENT: JWS Copy a .jws source file into your Axis-enabled Web application. All public methods in the class will be exposed as service operations. Only datatypes Axis knows about for your Web services ar global ones. If use java types in JWS code that are not part of type mapping Axis support, u mus declare global type before JWS service will function. AxisServer's configuration is in a file called serverconfig.wsdd Each service is deployed in the server has a <service> element in this file. Service name is last portion of the URL endpoint to access the service. Ex: service is called submitPO URL to access it will be http://localhost:8080/axis/services/submitPO style attribute tells ways Axis can map SOAP messages to and from java method calls: rpc, document, wrapped,or message. When specify style, not need use or provider attributes b/c they are default based on style chosen If not specified, default style is rpc. 1>java:RPC is standard RPC provider(org.apache.axis.providers.java.RPCProvider when use RPC provider, two important pieces of information to provider; which class and methods are allowed by using service parameters: <parameter name="className" value="class name"/> value is full class name of your web service <parameter name="allowedMethods" value="methods"/> value is a space-separated list of methods you want accessible as Web service operation.
If use value *, u means all public methods on your service class 2>java:MSG - the message provider(org.apache.axis.providers.java.MsgProvider) handles dispatching raw XML to you service. If set java:MSG provider, style will be auto set message 3>java:EJB - the EJB provider(org.apache.axis.providers.java.EJBProvider) allows to use Enterprise javabean as a Web service. 4>Handler - your handler class as provider of a service. Ex: org.apache.axis.handlers.EchoHandler places a request message into the response message. You declare an echo service like this: <service name="echo provider="Handler"> <parameter name="handlerClass" value="org.apache.axis.handlers.EchoHandler"/> </service> Misc:BSF Beand Scripting framework, COM Miscorsof Common Object Model, CORBA for Java RMI use attribute specify encoded or literal use to control whether SOAP encoding is used when service serializes and deserializes XML. If <typeMapping> or <beanMapping> elements are inside your service deployment, the XML/Java mappings holds only for that service. This enables many services to map the same types in different ways. Axis engine can find the correct service if an element in one of namespaces is found in the <soap:body> <namespace> determines the namespace of the body elements of the service. <wsdlFile> allows to specify a custom WSDL file the engine returns when asked about the WSDL for this service. WSDD FOR SERVICES <service name="name" [style="rpc/wrapped/document/message"] [use="literal/encoded"] [provider="provider"]> <operation>* <typeMapping>*/<beanMapping>* <namespace>uri</namespace> <wsdlFile>absolute-filename</wsdlFile> <endpointURL>uri</endpointURL> <handlerInfoChain> <parameter name="name" value="value"/> </service> JAX-RPC HANDLERS
Unlike Axis handler, JAX-RPC handler has 2 methods to invoke: handleRequest() and handleResponse() Axis handler has invoke() and check MessageContext if necessary to figure out whether the current message is the request or response. Each <handlerInfo> defines a single JAX-RPC handler. <handlerInfoChain> <handlerInfo class="className"> <parameter name=" " value=" '/> <header qname="qname" />* <role soapActorName="uri"/>* </handlerInfo> </handlerInfoChain> The <operation> element is used to control options in an operation. control how parameters to methods map to XML elements and how Exceptions thrown by java methods map to and from SOAP faults. <operation name="name" [qname="qname"] [returnQName="qname"] [returnType="qname"] [returnHeader="true/false"]> <parameter [qname="" | name=" "] [mode="in/out/inout"] type="qname" inHeader="true/false" outHeader="true/false"/>* <fault name="name" qname="qname" class="classname" type="qname"/>* </operation> DEPLOYING SERVICES AND THE ADMINCLIENT 2 choices to get WSDD into a server's configuration. 1. directly edit server-config.wsdd file that server is using in WEB-INF/ of your web app. 2. use AdminClient tool that comes with Axis The client is a class org.apache.axis.client.AdminClient java org.apahce.axis.client.AdminClient [-u{username}] [-w{password}] [-p{port}] [-l{service-url}] {wsdd-file} When run this from command line, it reads the specified WSDD file and deploys it to Axis engine running at given URL. Default URL is http://localhost:8080/axis/services/AdminServices If WSDD has <deployment> as its root element, all components in WSDD are deployed into the server. Verify all the classes referred to in WSDD file are available on the server's classpath before doing deployment. If using <undeployment> as its root, all the components are removed from server. Put names of components you want undeployed in WSDD, not full configuration.
<undeployment xmlns="http://xml.apache.org/axis/wsdd/"> <handler name="handler"> <service name="service"> </undeployment> GETTING AT THE MESSAGECONTEXT The main thing is Services want to access to the MessageContext, b/c it contains references to everything: request and response messages, type-mapping registry, engine, current set of properties. How to get MessageContext? From anywhere in your service code by static method MessageContext.getCurrentContext(). Once getting it, use get/set properties, examines messages, find out transport in use, Example: //Our service method. float getPrice(){ //Get the regular price float result = getNormalPrice(); //Check if user has been authenticated by looking in a mc for a User object MessageContext mc = Messagecontext.getCurrrentContext(); User user = (User)mc.getProperty("myUserProperty"); //if an earlier handler dropped a User object in myUserProperty, //check if they have privileges if(user != null && user.isGoldMember() == true){ //If user is a gold member, give discount result = result*0.85f; } return result; } PROPERTY SCOPING AT RUNTIME u can set a configuration option on the axisengine, which can be overridedn by a particular service, which can be overriden again by handlers in a particular message. Ex: An Axis server might be configured by setting SEND_MULTIREFS to Boolean.False to avoid sending multirefs by default to speed up serialization of SOAP1.2 message. MessageContexts for that AxisServer would not return false if u called getProperty(SEND_MULTIREFS). A specific service deployed in that engine could set that same parameter to true and for invocation of that service alone, the new value would override the default.
SERVICE LIFECYCLE AND SCOPES When deploye a service, a java object implements the application logic. A service deployer has some choices for service objects via scope option on the service in WSDD. Example: <service name="MySingleton"> ..... <parameter name="scope" value="application"/> </service> application scope only one single instance of service class for entire Axisengine, all methods must be safethread. Many active request threading through the same code in parallel. Any state you keep in your service object will be shared across all invocations for the lifetime of the engine. request scope new service object is created for every SOAP request. it is default for services without option of scope. session scope: service objects are created per client session; once a session has been established with the Axisengine.
When the service object is created or destroyed by Axis at runtime, engine checks to see if that object implements an interface javax.xml.rpc.server.ServerLifecycle, containing 2 methods: void init(Object context) throws ServiceException; void destroy(); By implementing these methods, u can init or clean up your service object. Engine creates a new service object, init() is called with a context object, that lets service get at MessageContext and related properties. Object is of type javax.xml.rpc.server.ServletEndpointContext(This is not recommended as getMessageContext()) Free service objects for garbage collection. at shutdown or a session expires or at end of a request(for request-scoped object) SESSIONS ON THE SERVER SIDE USING WSDL2Java TO GENERATE SERVICES GENERATING WSDL for your Services USING JAVA2WSDL A GUIDE TO FOUR WEB SERVICE STYLES For simplicity, look at three elements <types><message><interface> in WSDL to identify each style of Web services: RPC STYLE use SOAP data model On the client, use invoke(methodName, arguments) API and each argument in the passed array turns into a SOAP RPC parameter. On the server, the first element in SOAP body is the method name by RPC convention. Axis server use QName of that element as key to send to the correct operation for RPC style services. WRAPPED STYLE messages are document/literal and no SOAP encoding A wrapper element is defined directly in the schema to represent the method name for each operation and a series of elements inside it, one for each parameter. <types> <schema targetNamespace="http://www.skatestown.com/" xmlns="http://www.w3.org/2001/XMLSchema"> <element name="doCheck">
<operation name="operation1"> <input message="docRequest"/> </operation> </interface> Note: Understand difference between document and wrapped style in term of java bindings: <soap:Envelope> <soap:Body> <setStockAlert> <price xsi:type="xsd:float">50</price> <symbol xsi:type="xsd:string">MSFT</symbol> </setStockAlert> </soap:Body> </soap:Envelope> If this SOAP message is sent to a document-style service, the java service method would be void operation(SetStockAlert body) Where operation is the operation name, SetStockAlert is a JavaBean that represents <setStockAlert> element in SOAP body: class SetStockAlert{ float price; String symbol; } If this SOAP message is sent to a wrapped-style service, the java service method would be void setStockAlert(float price, String symbol) method name is the same as name of XML element parameters are arguments of method Three styles: rpc, wrapped, document have one thing in common. Axis converts XML into java data structure and vice versa. MESSAGE STYLE is used when process with no data binding. In message style service, no need one java operation per Web service operation. Several ways to deal with XML,Axis provides signatures for your message-style operations: 1)void method(SOAPEnvelope request, SOAPEnvelop response) 2)Element [] method(Element[] request) 3)SOAPBodyElement[] method(SOAPBodyElement[] request) 4)Document method(Document request)
1.If your service look at whole SOAP envelope, including headers.The response SOAPEnvelope is passed in to your method,not generated it. 2 and 3.get all subelements of <soapenv:Body> and return collection of elements into response body. 4. DOm document holds contents of <soapenv:Body> and returns a DOM document for response body. (if more than one body element, don't use this method) FROM XML TO JAVA: THE AXIS TYPE-MAPPING SYSTEM REGISTERING MAPPINGS To make type mapping work, we need a registry of mapping. When engine read a piece of XML and see an element of a schema type, it locates deserializer to convert XML into java. Also When writing out Java objects as XML. It is called TypeMappingRegistry(TMR) contains TypeMapping and enable map XML and Java types. At any time, there is a TypeMapping object for each encodingStyle. TypeMappingRegistry can be accessed with messageContext.getTypeMappingRegistry() API messageContext.getTypeMapping()
THE APACHE MAP TYPE key/value associative array <schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:tns="http://xml.apache.org/xml-soap" targetNamespace="http://xml.apache.org/xml-soap"> <complexType name="Map"> <sequence> <element name="item" type="tns:mapItem" minOccurs="0" maxOccurs="unbounded"> <sequence> </complexType> <complexType name="mapItem"> <sequence> <element name="key" type="anyType"/> <element name="value" type="anyType"/> <sequence> </complexType> </schema> THE SOAP ENCODING DATATYPES SOAP encoding types map to java language wrapper types like Integer. MAPPING JAVA COLLECTIONS TO AND FROM XML Java collections classes and arrays will map to SOAP arrays in WSDL like this: Example 1: <complexType name="ArrayOfString"> <complexContent> <restriction base="soapenc:Array"> <attribute ref="soapenc:ArrayType" wsdlArrayType="xsd:string[]"> </complexContent> </complexType> int[] or string[], Axis will generate types as ArrayOfString But Collection class: ArrayList, Vector, WSDL language will map to a plain SOAP array, you can put object in it. Example 2: <complexType name="BagOfThings"> <sequence> <element name="things" type="xsd:int" minOccurs="0" maxOccurs="unbounded" /> </sequence> </complexType> We map BagOfThings type to a Java type: class BagOfThings {
int[] things; } Note: when elements with maxoccurs greater than 1 are fields in a type, they are converted to arrays. Similar to the wrapped mode parameters that have maxOccurs greater than 1. int getAverage(int[] values) <element name="getAverage"> <complexType> <element name="values" minOccurs="0" maxOccurs="unbounded" /> </complexType> </element> DEFAULT TYPE MAPPING AND XML/JAVA NAMING BeanSerializer and BeanDeserializer are default classes for reading and writing Java beans as XML complex types( <beanMapping>). Each field in a bean maps to an element or atribute in an XML complext type and vice versa. meta-data in getTypeDesc() of any data class generated by WSDL2java <complexType name="Nameclass"> <sequence> <element name="name" type="xsd:string"/> <attribute name="name" type="xsd:int"/> </sequence> </complexType> Both element and attribute associated with this type are called name, each map to Java field called name, except we canot have two identically named fields. Class NameClass{ String name; int name2; } CUSTOM SERIALIZERS AND DESERIALIZERS SERIALIZER void serializer(QName name, Attribute attributes, Object value,context) Note: The point of a serializer takes the Java object passed in the value argument and write it as XML to the passed SerializationContext.
SerializationContext do things: -write QNames with correct prefixes -remember which java ojbects written to implement multiref serialization. Use serializer to turn Java types into XML serialization. Use serializer to describe XML e.g. method writeSchema(): generate a schema description of XML. Element writeSchema(Class javaType, Types types) throws Exception Serializer returns a DOM element that describes XML that will be generated when serializing java type in JavaType argument. Note: Types reference that is also passed to the method allows ur code access to the types that have already been written and a few other convenient APIs for situations when your type definition needs to reference other types. Example: u have a Java datatype and write it to XML. 1.Write a Serializer implementation that takes an object of Java type and writes XML using a SerializationContext 2.Sure serializer writes a correct schema for the generated XML. 3.Write a factory implementation so that engine can create instances of ur serializer. The SerializerFactory u build will be the class you refer to as the serializer component in WSDD type mappings and in Call.registerTypeMapping() client APIs. DESERIALIZER process XML and end up with a Java object. SAX-based system SAX events public void startElement(String namespace,String localName, String qName,Attributes attributes,DeserializerContext context) To register deserializer, u need a factory class which implement org.apache.axis.encoding.DesrializerFactory USING THE MessageElement XML/OBJECT APIs MessageElement class: used to convert java to xml and vice versa SOAPElement class QName is called XML type Examaple: you have a header:
<soap:Header> <ns:RetryCount xmlns:ns="myNS" xsi:type="xsd:int">1</ns:RetryCount> </soap:Header> CREATING MessageElements from Java Objects Assumming u have a reference to the SOAPEnevelope, you can ask for its value. SOAPHeaderElement retryHeader= envelope.getHeaderByName("myNS","RetryCount"); Integer retryCount = (Integer)Header.getObjectValue(); If xsd:int type is not present in this element, will have error. Use other APIs to resolve this Integer val = (Integer)retryHeader.getObjectValue(Integer.class) However, messageElement also has xsd:type, Axis use valid mapping to deserialize appropriately element.getValueAsType(Constants.QNAME_XSD_STRING) element.getValueAsType(xmlType,javaType) Instead of passing class, use QNAME that is XML type to method Creating MessageElements from Java Objects A class or handler insert a SOAP header that maps to a complex Java data object. Write code to generate Header XML manually. Essentially writing a serializer SOAPHeaderElement myHeader = new SOAPHeaderElement(myQName,myObject); Adding a header: <myHeader> <myObj> <!-- serialized object data here --> </myObj> </myHeader> with API call myHeader = new SOAPHeader(myHeaderQName); MessageElement myEl = new MessageElement(myObjQName, myObject); FAULTS AND EXCEPTIONS Axis turns exception itno SOAP fault on the wire. If u want more direct control over SOAP fault data, faultCode, faultRole. You can choose to throw an AxisFault or any Exception derived from AxisFault. The AxisFault class class AxisFault{ //Fault code accessor QName getFaultCode();
void setFaultCode(QName code); //Fault string accessor String getFaultString(); void setFaultString(String faultString); //Support adding custome headers to a fault message ArrayList getHeaders(); void addHeaders(SOAPHeaderElement header); } On server side, if your class throw AxisFault, the resulting SOAP fault will reflect the values set in AxisFault class. AxisFault fault = new AxisFault(); fault.setFaultCode(new QName("","Server.NoProduct")); fault.setFaultString("No such product"); fault.addHeader(new SOAPHeaderElement("","PhoneNumber","123-4567")); throw fault; It would turn into this on the wire <soap:Envelope--------------------------- USING TYPED Exceptions FAULTS AND WSDL AXIS AS AN INTERMEDIARY REASONS FOR ROLES HOW TO WRITE A HANDLER THE SKATESTOWN EMAILHANDLER THE SKATESTOWN GLOBALHANDLER BUILT-IN SECURITY USING THE AUTHENTICATION/AUTHORIZATION HANDLERS UNDERSTANDING AXIS TRANSPORTS Most messages enter and leave system via HTTP CLIENT TRANSPORTS A new transport requires a class that inherits from org.apache.axis.client.Transport class. call.setTransport(myTransportObject); Or register as default handler for Url protocol Transport object is the client side equivalent to transport listener on server Before each invocation is passed to AxisClient,
Call object calls setupMessageContext() on Transport object. Transport object set MessageContext properties. SERVER TRANSPORTS First is transport listener is a piece of code to pull transport-specific message from somewhere and invoking Axis. Second is handlers associated with transport name passed in by the listener. Listener can be anything from a class with main() that polls for messages to a transport server framework. All take in messages, generate MessageContexts and deliver them to an AxisServer with transport name field set for server to find the targeted chain of classes/handlers to perform transport-specific processing. TRANSPORTS INCLUDED WITH AXIS JMS Java Message Service transport org.apache.axis.transport.jms this jms transport lets you send messages over the reliable JMS infrastructure ex: samples.jms Mail org.apache.axis.transport.mail The mail transport uses SOAP over email connections to communicate. Outgoing mail accepted by an SMTP server. Inbound side, mail transport uses POP3 to pull SOAP emails from a mailbox Local org.apache.axis.transport.local for testing. instantiates an AxisServer inside the transport itself and uses the server to handle the request. Java org.apache.transport.java invoke java methods directly without deploying service classes. U can access a URL java:mypackage:myclass and transport will call methods of myclass object as if it had been deployed as an RPC service. CUSTOM TRANSPORTS TCP transport File-base transport TCPListener class that has main class, can run from command line FileReader has not main(), must use Filetest handles. To make any custom transport, must need classes/jar file in classpath
NO API IS AN ISLAND: AXIS AND ITS ENVIRONMENT Axis can use plug-in functionality utilize other libraries for common functions. Commons-Discovery and Obtaining Resources Commons-Discovery is the framework Axis uses to get pluggabel resources. is used for the purposes: Ex: find a JMS implementation check configuration options, system properties or local properties find a concrete class implementing an interface Logging Infrastructure Axis use use commons-logging library for its logging functionality. Jave has 3 commonly used logging systems: 1. log4j 2. jlog 3. native logging in jdk1.4 Security Providers Secure Socket factory are in org.apache.axis.components.net package select one to use by set system property org.apache.axis.components.net.SecureSocketFactory to the SecureSocketFactory class Compilers Axis compile JWS file by standard javac compiler Development/Debugging Tools Axis provides aid to develop, debug clients and services Libraries JMS transport, XML/java binding system commons-discovery library XML parser Configuring Logging By default, commons-logging package looks for a log4j installation and uses that as its concrete logger However, can configure to use other loggers. Logging is a common way to diagnose and debug problem log4j defines levels of severity for each event that might be logged. DEBUG: if you want debugging
INFO: informative messages but not critical ERROR: problem tracking FATAL: serious problem loggers correspond to areas of system. Generally, events are logged with loggers. A logger is associated with each class. U can configure various log destinations like console, and log files, then control which events from which loggers go to which destinations. Log4j looks for a file called log4j.properties in one of directories on your classpath. U can find defautl version of this configuration file in Axis distribution which defines appenders: one for console and one for a log file called axis.log #set root category priority to INFO and its only appender to CONSOLE. log4j.rootCategory=INFO,CONSOLE This line results by default all messages of INFO or higher priority are sent to console logger. Can change INFO to ERROR OR FATAL OR DEBUT OR change CONSOLE TO LOGFILE If you want to debug a portion of the system like AxisServlet, log4j.logger.org.apache.axis.transport.http.AxisServlet=DEBUG,CONSOLE This line sets the AxisServlet logger to print DEBUG messages. Using tcpmon and SOAPMonitor deploy and use Web services. 2 ways: tcpmon application and SOAPMonitor servlet. start tcpmon java org.apache.axis.utils.tcpmon <localhost> <remoteHost> <remotePort> local port, remote host, remote port tells TCP monitor which local port to listen on and where messages recieved by that port should be forwarded. If select Proxy, tcpmon will expect an HTTP proxy which means clients will send HTTP headers to tell tcpmon to forward each message. If select listener, tcpmon is endpoint, then u need configure real endpoint's hostname and port number. Axis future
Participating in the Axis community SUMMARY http://axis.apache.org/axis2/java/core/download.cgi Features of Apache Axis2: Programming Model - Simple XML-centric client API with full WSDL and policy support - Support for POJO and Spring services and clients - Support for any message exchange pattern (MEP) - Synchronous and asynchronous programming model - Archived service deployment model supporting full service encapsulation with versioning support - Archived module deployment model supporting controlled extensibility with versioning support - Hot deployment - WS-Policy driven code generation extensions - Flexible service life cycle model - Automatic support for POX (REST) style invocation of services - Support for querying service's WSDL (with ?wsdl), schema (with ?xsd) and policies (with ?policy) Supported Specifications - SOAP 1.1 and 1.2 - Message Transmission Optimization Mechanism (MTOM) - XML Optimized Packaging (XOP) - SOAP with Attachments - WSDL 1.1, including both SOAP and HTTP bindings , WSDL 2.0 - WS-Addressing submission and 1.0 - WS-Policy - SAAJ 1.1 Transports - HTTP - SMTP - JMS - TCP - udp - xmpp For more details refer to the Axis2 Transports project. Supported Data Bindings - Axis Data Binding (ADB) - XMLBeans - JibX - JAXB Tools
- WSDL2Java: Generate Java stubs and skeletons from a WSDL document. - Java2WSDL: Generate a WSDL document from a Java class. - Eclipse Plugins - IntelliJ Idea Plugins - Maven2 Plugins - Web application for administering Apache Axis2 Modules supporting WS-Security/Secure-Conversation (Apache Rampart), WS-Trust (Apache Rahas), WS-Reliable Messaging (Apache Sandesha) and WS-Eventing (Apache Savan) will be available soon after the Apache Axis2 @axisVersion@ release. Please see these projects' own sites for further information.
![Refactoring Neural Networks for Verification · Refactoring for Verification: To achieve this we adapt the concept of refactoring to deep neural networks. Code refactoring [32]](https://static.documents.pub/doc/80x56/5f99f55ef5020022ff11f3a9/refactoring-neural-networks-for-veriication-refactoring-for-veriication-to.jpg)
