Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.axis2.jaxws.handler; import org.apache.axis2.jaxws.ExceptionFactory; import org.apache.axis2.jaxws.core.MessageContext; import org.apache.axis2.jaxws.description.DescriptionFactory; import org.apache.axis2.jaxws.description.EndpointDescription; import org.apache.axis2.jaxws.description.ResolvedHandlersDescription; import org.apache.axis2.jaxws.description.ServiceDescription; import org.apache.axis2.jaxws.description.impl.ResolvedHandlersDescriptionImpl; import org.apache.axis2.jaxws.description.xml.handler.HandlerChainType; import org.apache.axis2.jaxws.description.xml.handler.HandlerChainsType; import org.apache.axis2.jaxws.description.xml.handler.HandlerType; import org.apache.axis2.jaxws.handler.lifecycle.factory.HandlerLifecycleManager; import org.apache.axis2.jaxws.handler.lifecycle.factory.HandlerLifecycleManagerFactory; import org.apache.axis2.jaxws.i18n.Messages; import org.apache.axis2.jaxws.registry.FactoryRegistry; import org.apache.axis2.jaxws.spi.handler.BaseHandlerResolver; import org.apache.axis2.util.LoggingControl; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import javax.xml.namespace.QName; import javax.xml.ws.WebServiceException; import javax.xml.ws.handler.Handler; import javax.xml.ws.handler.LogicalHandler; import javax.xml.ws.handler.PortInfo; import javax.xml.ws.handler.soap.SOAPHandler; import java.lang.ref.WeakReference; import java.util.ArrayList; import java.util.Iterator; import java.util.List; /* * This class should be created by the ServiceDelegate. * HandlerResolverImpl.getHandlerChain(PortInfo) will be called by the * InvocationContext, and the return value will be set on the Binding * under the BindingProvider. * * HandlerResolverImpl.getHandlerChain(PortInfo) will be responsible for * starting each Handler's lifecycle according to JAX-WS spec 9.3.1 */ public class HandlerResolverImpl extends BaseHandlerResolver { private static Log log = LogFactory.getLog(HandlerResolverImpl.class); /* * TODO: is there any value/reason in caching the list we collect from the * ports? It is a "live" list in the sense that we could possibly return * a List or ArrayList object to a service or client application, where * they could manipulate it. */ private ServiceDescription serviceDesc; private WeakReference<Object> serviceDelegateKeyReference; public HandlerResolverImpl(ServiceDescription sd) { this(sd, null); } public HandlerResolverImpl(ServiceDescription sd, Object serviceDelegateKey) { this.serviceDesc = sd; if (serviceDelegateKey != null) { this.serviceDelegateKeyReference = new WeakReference<Object>(serviceDelegateKey); } } private ResolvedHandlersDescription getResolvedHandlersDescription(PortInfo portInfo) { ResolvedHandlersDescription resolvedHandlersDesc = null; // On the client the handler information can be changed via service-delegate-specific // deployment information. So, only look into the service-side cache only if the // service delegate key is null. if (getServiceDelegateKey() == null) { resolvedHandlersDesc = serviceDesc.getResolvedHandlersDescription(portInfo); } return resolvedHandlersDesc; } private Object getServiceDelegateKey() { Object returnKey = null; if (serviceDelegateKeyReference != null) { returnKey = serviceDelegateKeyReference.get(); } return returnKey; } private ResolvedHandlersDescription getOrCreateResolvedHandlersDescription(PortInfo portInfo) { ResolvedHandlersDescription resolvedHandlersDesc = null; // On the client the handler information can be changed via service-delegate-specific // deployment information. So, only look into the service-side cache only if the // service delegate key is null. if (getServiceDelegateKey() == null) { resolvedHandlersDesc = serviceDesc.getResolvedHandlersDescription(portInfo); if (resolvedHandlersDesc == null) { resolvedHandlersDesc = DescriptionFactory.createResolvedHandlersDescription(); } } return resolvedHandlersDesc; } private List<Class> geCachedResolvedHandlersClasses(PortInfo portInfo) { List<Class> cachedHandlerClasses = null; ResolvedHandlersDescription resolvedHandlersDesc = getResolvedHandlersDescription(portInfo); if (resolvedHandlersDesc != null) { cachedHandlerClasses = resolvedHandlersDesc.getHandlerClasses(); } return cachedHandlerClasses; } private void cacheResolvedHandlersInfo(PortInfo portInfo, List<Class> handlerClasses, List<String> roles) { ResolvedHandlersDescription resolvedHandlersDesc = getOrCreateResolvedHandlersDescription(portInfo); if (resolvedHandlersDesc != null) { resolvedHandlersDesc.setHandlerClasses(handlerClasses); resolvedHandlersDesc.setRoles(roles); serviceDesc.setResolvedHandlersDescription(portInfo, resolvedHandlersDesc); } } private List<Class> getHandlerClasses(PortInfo portInfo) { List<Class> handlerClasses = geCachedResolvedHandlersClasses(portInfo); if (handlerClasses == null) { List<String> resolveRoles = new ArrayList<String>(); handlerClasses = resolveHandlers(portInfo, resolveRoles); cacheResolvedHandlersInfo(portInfo, handlerClasses, resolveRoles); } return handlerClasses; } private List<String> getHandlerRoles(PortInfo portInfo) { List<String> resolveRoles = getCachedResolvedHandlersRoles(portInfo); if (resolveRoles == null) { resolveRoles = new ArrayList<String>(); List<Class> resolveClasses = resolveHandlers(portInfo, resolveRoles); cacheResolvedHandlersInfo(portInfo, resolveClasses, resolveRoles); } return resolveRoles; } private List<String> getCachedResolvedHandlersRoles(PortInfo portInfo) { List<String> cachedHandlerRoles = null; ResolvedHandlersDescription resolvedHandlersDesc = getResolvedHandlersDescription(portInfo); if (resolvedHandlersDesc != null) { cachedHandlerRoles = resolvedHandlersDesc.getRoles(); } return cachedHandlerRoles; } public List<Handler> getHandlerChain(PortInfo portInfo) { List<Class> handlerClasses = getHandlerClasses(portInfo); if (handlerClasses.size() == 0) { return new ArrayList<Handler>(); } ArrayList<Handler> handlers = new ArrayList<Handler>(); // Create temporary MessageContext to pass information to HandlerLifecycleManager MessageContext ctx = new MessageContext(); ctx.setEndpointDescription(serviceDesc.getEndpointDescription(portInfo.getPortName())); HandlerLifecycleManager hlm = createHandlerlifecycleManager(); for (Iterator<Class> iterator = handlerClasses.iterator(); iterator.hasNext();) { Class aClass = iterator.next(); // instantiate portHandler class try { handlers.add(hlm.createHandlerInstance(ctx, aClass)); } catch (Exception e) { // TODO: should we just ignore this problem? throw ExceptionFactory.makeWebServiceException(e); } if (LoggingControl.debugLoggingAllowed && log.isDebugEnabled()) { log.debug("Successfully instantiated the class: " + aClass); } } return handlers; } public List<String> getRoles(PortInfo portInfo) { List<String> handlerRoles = getHandlerRoles(portInfo); return handlerRoles; } /* * The list of handlers (rather, list of class names) is already * available per port. Ports are stored under the ServiceDelegate * as PortData objects. * * The resolveHandlers method is responsible for instantiating each Handler, * running the annotated PostConstruct method, resolving the list, * and returning it. We do not sort here. */ /** * Resolve the handlers and roles for the given port. This will process the handler configuration * information, which can be specified either in a file on a HandlerChain annotaiton or via a * deployment descriptor. The handler classes and the SOAP roles played will be resolved and * returned. * * @param portinfo Information describing the port for which the handlers and roles are to be * resolved * @param handlerRoles OUTPUT PARAMETER! The List that is passed in will be updated with the * roles relevant to the specfied port. * @return List of handler classes relevant to the specified port. * @throws WebServiceException */ private ArrayList<Class> resolveHandlers(PortInfo portinfo, List<String> handlerRoles) throws WebServiceException { /* A sample XML file for the handler-chains: <jws:handler-chains xmlns:jws="http://java.sun.com/xml/ns/javaee"> <jws:handler-chain> <jws:protocol-bindings>##XML_HTTP</jws:protocol-bindings> <jws:handler> <jws:handler-name>MyHandler</jws:handler-name> <jws:handler-class>org.apache.axis2.jaxws.MyHandler</jws:handler-class> </jws:handler> </jws:handler-chain> <jws:handler-chain> <jws:port-name-pattern>jws:Foo*</jws:port-name-pattern> <jws:handler> <jws:handler-name>MyHandler</jws:handler-name> <jws:handler-class>org.apache.axis2.jaxws.MyHandler</jws:handler-class> <jws:soap-role>http://org/apache/axis2/jaxws/MyRole</jws:soap-role> </jws:handler> </jws:handler-chain> <jws:handler-chain> <jws:service-name-pattern>jws:Bar</jws:service-name-pattern> <jws:handler> <jws:handler-name>MyHandler</jws:handler-name> <jws:handler-class>org.apache.axis2.jaxws.MyHandler</jws:handler-class> </jws:handler> </jws:handler-chain> </jws:handler-chains> Couple of things I'm not sure about... 1) if the protocol-binding, port-name-pattern, and service-name-pattern all match the PortInfo object, does MyHandler get added three times? Probably would get added 3 times. 2) I assume the asterisk "*" is a wildcard. Can the asterisk only occur on the local part of the qname? 3) Can there be more than one service-name-pattern or port-name-pattern, just like for protocol-bindings? 4) How many protocol-bindings are there? ##XML_HTTP ##SOAP11_HTTP ##SOAP12_HTTP ##SOAP11_HTTP_MTOM ##SOAP12_HTTP_MTOM They are separated by spaces */ // our implementation already has a reference to the EndpointDescription, // which is where one might get the portinfo object. We still have the // passed-in variable, however, due to the spec ArrayList<Class> handlers = new ArrayList<Class>(); /* * TODO: do a better job checking that the return value matches up * with the PortInfo object before we add it to the chain. */ // The HandlerChain annotation can be specified on: // - a service implementation (per JSR-181) which is on the service-provider side // - an SEI (per JSR-181), which can be on both the service-provider and // service-requester sides // - a generated Service (per JSR-224), which is on the service-requester side // // The order of precedence here is a bit counter intuitive if the HandlerChain annotation // is present on more than one class. // - For the service-provider, JSR-181 [p. 25, Section 4.6.1] // states that the service implementation's HandlerChain takes is used if it is present // on both the implementation and the SEI. // - Following that same pattern, we conclude that a generated service HandlerChain should // take precedence if the annotation is on both the Service and the SEI. // // The reasoning for this is (probably) that the SEI can be used by multiple endpoints // and / or multiple Service requesters, so the endpoint implementation and the Service // should have the final say in what handlers are run, rather than the SEI. // // Adding Deployment Descriptors complicates this further. A DD should have the absolute // final say (such as a JSR-109 client DD). Given that, on a service-requester if the // Service has a HandlerChain and the SEI has a HandlerChain and the DD specifies a // HandlerChain for a port, then the DD should win. Since DDs are implented as information // in a sparse composite, then that means the sparse composite wins. // Get the HandlerChains specified on the Endpoint (service-provider) or on the Service // (service-requester). handlerChainsType = serviceDesc.getHandlerChain(getServiceDelegateKey()); // HandlerChains apply to specific Port Compoments (service-provider) or Ports ( // (service-requesters) so find the appropriate one. EndpointDescription ed = null; if (portinfo != null) { ed = serviceDesc.getEndpointDescription(portinfo.getPortName()); } // Get the HandlerChain information, if any, off the SEI (service-provider or // service-requster) and check for any DD overrides. if (ed != null) { // If there was no handler chains information specifed on the endpoint (service- // provider) or the Service (service-requester) // -- OR -- // If the handler chains associated with a particular instance of a service delegate // DOES NOT match the handler chains across all service delegates, then there was // sparse composite information specified for this service delegate. Sparse composite // information is how Deployment Descriptor information is specified, and that // overrides the annotations as described in the long-winded comment above. // -- THEN -- // Use this handler chains information HandlerChainsType hct_includingComposite = ed.getHandlerChain(getServiceDelegateKey()); HandlerChainsType hct_noComposite = ed.getHandlerChain(); if (handlerChainsType == null || (hct_includingComposite != hct_noComposite)) { handlerChainsType = hct_includingComposite; } } else { // There is no EndpointDescription that matches the portInfo specified so // return the empty list of handlers since there are no ports that match if (log.isDebugEnabled()) { QName qName = (portinfo == null) ? null : portinfo.getPortName(); log.debug("The PortInfo object did not match any ports; returning an empty list of handlers." + " PortInfo QName: " + qName); } return handlers; } Iterator it = handlerChainsType == null ? null : handlerChainsType.getHandlerChain().iterator(); while ((it != null) && (it.hasNext())) { HandlerChainType handlerChainType = ((HandlerChainType) it.next()); // if !match, continue (to next chain) if (!(chainResolvesToPort(handlerChainType, portinfo))) continue; List<HandlerType> handlerTypeList = handlerChainType.getHandler(); Iterator ht = handlerTypeList.iterator(); while (ht.hasNext()) { HandlerType handlerType = (HandlerType) ht.next(); // TODO must do better job comparing the handlerType with the PortInfo param // to see if the current iterator handler is intended for this service. // TODO review: need to check for null getHandlerClass() return? // or will schema not allow it? String portHandler = handlerType.getHandlerClass().getValue(); Class aClass; try { aClass = loadClass(portHandler); } catch (Exception e) { // TODO: should we just ignore this problem? throw ExceptionFactory.makeWebServiceException(e); } // 9.2.1.2 sort them by Logical, then SOAP if (LogicalHandler.class.isAssignableFrom(aClass)) handlers.add(aClass); else if (SOAPHandler.class.isAssignableFrom(aClass)) // instanceof ProtocolHandler handlers.add(aClass); else if (Handler.class.isAssignableFrom(aClass)) { throw ExceptionFactory .makeWebServiceException(Messages.getMessage("handlerChainErr1", aClass.getName())); } else { throw ExceptionFactory .makeWebServiceException(Messages.getMessage("handlerChainErr2", aClass.getName())); } // If a role was specified, add it to the roles played if (handlerRoles != null) { List<org.apache.axis2.jaxws.description.xml.handler.String> soapRolesList = handlerType .getSoapRole(); Iterator<org.apache.axis2.jaxws.description.xml.handler.String> soapRolesIterator = soapRolesList .iterator(); while (soapRolesIterator.hasNext()) { org.apache.axis2.jaxws.description.xml.handler.String soapRoleElement = soapRolesIterator .next(); String addSoapRole = soapRoleElement.getValue(); handlerRoles.add(addSoapRole); if (log.isDebugEnabled()) { log.debug("Adding soap role " + addSoapRole); } } } } } return handlers; } private HandlerLifecycleManager createHandlerlifecycleManager() { HandlerLifecycleManagerFactory elmf = (HandlerLifecycleManagerFactory) FactoryRegistry .getFactory(HandlerLifecycleManagerFactory.class); return elmf.createHandlerLifecycleManager(); } }