Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright (c) 1997-2012 Oracle and/or its affiliates. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License.  You can
  * obtain a copy of the License at
  * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
  * or packager/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at packager/legal/LICENSE.txt.
  *
  * GPL Classpath Exception:
  * Oracle designates this particular file as subject to the "Classpath"
  * exception as provided by Oracle in the GPL Version 2 section of the License
  * file that accompanied this code.
  *
  * Modifications:
  * If applicable, add the following below the License Header, with the fields
  * enclosed by brackets [] replaced by your own identifying information:
  * "Portions Copyright [year] [name of copyright owner]"
  *
  * Contributor(s):
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  */
 
 package org.glassfish.webservices;
 
 
 import java.net.URL;
 
 import java.util.Set;
 import java.util.Map;
 import java.util.List;
 
 
 
InvocationHandler used to intercept calls to concrete JAXRPC Service implementation. NOTE : This class makes no distinction between "partial" WSDL and "full" WSDL. If a service-ref's packaged WSDL is "partial", the deployer is required to specify a wsdl-override in the runtime info that points to a final WSDL. In such a case, the behavior for each method listed in the table in section 4.2.2.7 of the spec is the same as Full WSDL.

Author(s):
Kenneth Saks
 
 public class ServiceInvocationHandler implements InvocationHandler {
 
 
     // real service instance
     private Service serviceDelegate;
 
     // used in full wsdl case for DII methods. Lazily instantiated.
     private volatile Service configuredServiceDelegate;
 
     private ClassLoader classLoader;
 
 
    // location of full wsdl associated with service-ref
    private URL wsdlLocation;
    private boolean fullWsdl = false;
    
    private WsUtil wsUtil = new WsUtil();
    // Service method types
    private static final int CREATE_CALL_NO_ARGS = 1;
    private static final int CREATE_CALL_PORT = 2;
    private static final int CREATE_CALL_OPERATION_QNAME = 3;
    private static final int CREATE_CALL_OPERATION_STRING = 4;
    private static final int GET_CALLS = 5;
    private static final int GET_HANDLER_REGISTRY = 6;
    private static final int GET_PORT_CONTAINER_MANAGED = 7;
    private static final int GET_PORT_CLIENT_MANAGED = 8;
    private static final int GET_PORTS = 9;
    private static final int GET_SERVICE_NAME = 10;
    private static final int GET_TYPE_MAPPING_REGISTRY = 11;
    private static final int GET_WSDL_LOCATION = 12;
    private static final int GENERATED_SERVICE_METHOD = 13;
    private static Map serviceMethodTypes;
    private static Set fullWsdlIllegalMethods;
    private static Set noWsdlIllegalMethods;
    static {
        init();
    }
                                    Service delegateClassLoader loader)
            throws Exception {
         = descriptor;
         = delegate;
         = loader;
        if.hasWsdlFile() ) {
             = true;
        } 
                ("getPort"new Class[] { QName.classClass.class } );
        if (Globals.getDefaultHabitat() != null) {
             = Globals.get(org.glassfish.webservices.SecurityService.class);
        }
        addMessageSecurityHandler(delegate);
    }
    public Object invoke(Object proxyMethod methodObject[] args)
            throws Throwable {
        // NOTE : be careful with "args" parameter.  It is null
        //        if method signature has 0 arguments.
        ifmethod.getDeclaringClass() == java.lang.Object.class )  {
            return invokeJavaObjectMethod(thismethodargs);
        }
        int methodType = getMethodType(method);
        checkUnsupportedMethods(methodType);
        Object returnValue = null;
        try {
            // Initialize method info for invocation based on arguments.
            // Some/All of this might be overridden below.
            Object serviceToInvoke = ;
            Method methodToInvoke  = method;
            int methodTypeToInvoke = methodType;
            Object[] argsForInvoke = args;
            switch(methodType) {
                case  :
                    Class serviceEndpointInterfaceClass = (Classargs[0];
                    String serviceEndpointInterface =
                            serviceEndpointInterfaceClass.getName();
                    ServiceRefPortInfo portInfo =
                            .getPortInfo(serviceEndpointInterface);
                    // If we have a port, use it to call getPort(QName, SEI) instead
                    if( (portInfo != null) && portInfo.hasWsdlPort() ) {
                        methodToInvoke = ;
                        methodTypeToInvoke = ;
                        argsForInvoke  = new Object[] { portInfo.getWsdlPort(),
                                args[0] };
                    } else {
                        // This means the deployer did not resolve the port to
                        // which this SEI is mapped.  Just call getPort(SEI)
                        // method on delegate. This is not guaranteed to work.
                    }
                    break;
                case  :
                    return ;
                case  :
                case  :
                case  :
                case  :
                case  :
                    serviceToInvoke = getConfiguredServiceDelegate();
                    break;
                default:
                    break;
            } // End switch (methodType)
            returnValue = methodToInvoke.invoke(serviceToInvokeargsForInvoke);
            ifreturnValue instanceof Stub ) {
                Stub stub = (StubreturnValue;
                setStubProperties(stubmethodTypeToInvokemethodToInvoke,
                        argsForInvoke);
            } else ifreturnValue instanceof Call ) {
                Call[] calls = new Call[1];
                calls[0] = (CallreturnValue;
                setCallProperties(callsmethodTypeToInvokeargsForInvoke);
            } else ifmethodType ==  ) {
                Call[] calls = (Call[]) returnValue;
                setCallProperties(callsmethodTypeToInvokeargsForInvoke);
            }
        } catch(InvocationTargetException ite) {
            throw ite.getCause();
        }
        return returnValue;
    }
    {
        HandlerInfo rvalue = null;
        MessageSecurityBindingDescriptor binding = null;
        ServiceRefPortInfo portInfo = .getPortInfoByPort(port);
        if (portInfo != null) {
            binding = portInfo.getMessageSecurityBinding();
        }
        if ( != null) {
           rvalue = .getMessageSecurityHandler(binding.getServiceName());
        }
        return rvalue;
    }
    private boolean addMessageSecurityHandler(Service servicethrows Exception
    {
        HandlerRegistry registry = service.getHandlerRegistry();
        Iterator ports = null;
        try {
            ports = service.getPorts();
        } catch (Exception e) {
            // FIXME: should make sure that the exception was thrown because
            // the service is not fully defined; but for now just return.
            ports = null;
        }
        while(ports != null && ports.hasNext()) {
            QName nextPort = (QNameports.next();
            List handlerChain = registry.getHandlerChain(nextPort);
            // append security handler to the end of every handler chain
            // ASSUMPTION 1: that registry.getHandlerChain() never returns null.
            // ASSUMPTION 2: that handlers from ServiceRef have already been added
            HandlerInfo handlerInfo = getMessageSecurityHandlerInfo(nextPort);
            if (handlerInfo != null) {
                handlerChain.add(handlerInfo);
            }
        }
        return ports == null ? false : true;
    }
    private Service getConfiguredServiceDelegate() throws Exception {
        if ( == null) {
            // We need a ConfiguredService to handle these
            // invocations, since the JAXRPC RI Generated Service impl
            // does not.  Configured service is potentially
            // a heavy-weight object so we lazily instantiate it to
            // take advantage of the likelihood that
            // GeneratedService service-refs won't be used for DII.
            Service configuredService =
                    .createConfiguredService();
            .configureHandlerChain(configuredService,
                    configuredService.getPorts(), );
             = configuredService;
            addMessageSecurityHandler(configuredService);
        }
        return ;
    }
    private int getMethodType(Method method) {
        Integer methodType = (Integer.get(method);
        return (methodType != null) ?
                methodType.intValue() : ;
    }

    
Convert invocation method to a constant for easier processing.
    private static void init() {
             = new HashMap();
         = new HashSet();
           = new HashSet();
        try {
            Class noParams[]   = new Class[0];
            String createCall  = "createCall";
            Class serviceClass = javax.xml.rpc.Service.class;
            //
            // Map Service method to method type.
            //
            Method createCallNoArgs =
                    serviceClass.getDeclaredMethod(createCallnoParams);
            .put(createCallNoArgs,
                    Integer.valueOf());
            Method createCallPort =
                    serviceClass.getDeclaredMethod(createCall,
                            new Class[] { QName.class });
            .put(createCallPort,
                     Integer.valueOf());
            Method createCallOperationQName =
                    serviceClass.getDeclaredMethod
                            (createCallnew Class[] { QName.classQName.class });
            .put(createCallOperationQName,
                     Integer.valueOf());
            Method createCallOperationString =
                    serviceClass.getDeclaredMethod
                            (createCallnew Class[] { QName.classString.class });
            .put(createCallOperationString,
                    Integer.valueOf());
            Method getCalls = serviceClass.getDeclaredMethod
                    ("getCalls"new Class[] { QName.class });
            .put(getCalls,  Integer.valueOf());
            Method getHandlerRegistry = serviceClass.getDeclaredMethod
                    ("getHandlerRegistry"noParams);
            .put(getHandlerRegistry,
                     Integer.valueOf());
            Method getPortContainerManaged = serviceClass.getDeclaredMethod
                    ("getPort"new Class[] { Class.class });
            .put(getPortContainerManaged,
                    Integer.valueOf());
            Method getPortClientManaged = serviceClass.getDeclaredMethod
                    ("getPort"new Class[] { QName.classClass.class });
            .put(getPortClientManaged,
                    Integer.valueOf());
            Method getPorts = serviceClass.getDeclaredMethod
                    ("getPorts"noParams);
            .put(getPorts, Integer.valueOf());
            Method getServiceName = serviceClass.getDeclaredMethod
                    ("getServiceName"noParams);
            .put(getServiceName,
                     Integer.valueOf());
            Method getTypeMappingRegistry = serviceClass.getDeclaredMethod
                    ("getTypeMappingRegistry"noParams);
            .put(getTypeMappingRegistry,
                    Integer.valueOf());
            Method getWsdlLocation = serviceClass.getDeclaredMethod
                    ("getWSDLDocumentLocation"noParams);
            .put(getWsdlLocation,
                     Integer.valueOf());
        } catch(NoSuchMethodException nsme) {}
        // Implementation of table 4.2.2.7.  All "No WSDL" column cells
        // with value Unspecified throw UnsupportedOperationException
        // This case shouldn't happen since if service-ref has generated
        // service and no WSDL it won't get past deployment, but it's here
        // for completeness.
    }
    private void checkUnsupportedMethods(int methodType)
            throws UnsupportedOperationException {
        Set illegalMethods =  ?
                 : ;
        ifillegalMethods.contains( Integer.valueOf(methodType)) ) {
            throw new UnsupportedOperationException();
        }
        return;
    }
    private void setStubProperties(Stub stubint methodTypeMethod method,
                                   Object[] args) {
        // Port info lookup will be based on SEI or port.
        QName port = null;
        String serviceEndpointInterface = null;
        switch(methodType) {
            case  :
                serviceEndpointInterface = ((Classargs[0]).getName();
                break;
            case  :
                port = (QNameargs[0];
                serviceEndpointInterface = ((Classargs[1]).getName();
                break;
            case  :
                // java.rmi.Remote get<Name_of_wsdl:port>()
                String portLocalPart = method.getName().startsWith("get") ?
                        method.getName().substring(3) : null;
                ifportLocalPart != null ) {
                    QName serviceName = .getServiceName();
                    port = new QName(serviceName.getNamespaceURI(), portLocalPart);
                }
                serviceEndpointInterface = method.getReturnType().getName();
                break;
            default :
                return;
        }
        ServiceRefPortInfo portInfo = null;
        // If port is known, it takes precedence in lookup.
        ifport != null ) {
            portInfo = .getPortInfoByPort(port);
        }
        ifportInfo == null ) {
            portInfo = .getPortInfoBySEI(serviceEndpointInterface);
        }
        ifportInfo != null ) {
            Set properties = portInfo.getStubProperties();
            for(Iterator iter = properties.iterator(); iter.hasNext();) {
                NameValuePairDescriptor next = (NameValuePairDescriptor)
                        iter.next();
                stub._setProperty(next.getName(), next.getValue());
            }
            // If this port has a resolved target endpoint address due to a
            // port-component-link, set it on stub.  However, if the runtime
            // info has an entry for target endpoint address, that takes 
            // precedence.
            ifportInfo.hasTargetEndpointAddress() ) {
                if(!portInfo.hasStubProperty(.)) {
                    stub._setProperty(.,
                            portInfo.getTargetEndpointAddress());
                }
            }
        }
    }
    private void setCallProperties(Call[] callsint methodTypeObject[] args){
        Set callProperties = getPropertiesForCall(methodTypeargs);
        ifcallProperties != null ) {
            for(int callIndex = 0; callIndex < calls.lengthcallIndex++) {
                setCallProperties(calls[callIndex], callProperties);
            }
        }
    }
    private Set getPropertiesForCall(int methodTypeObject args[]) {
        Set callProperties = null;
        switch(methodType) {
            case  :
            case  :
            case  :
            case  :
                // Each of these methods has port as first argument.
                QName port = (QNameargs[0];
                // Check if call properties are set at the port level.
                ServiceRefPortInfo portInfo =
                        .getPortInfoByPort(port);
                ifportInfo != null ) {
                    callProperties = portInfo.getCallProperties();
                }
                break;
            case  :
                callProperties = .getCallProperties();
                break;
            default:
                break;
        }
        return callProperties;
    }
    private void setCallProperties(Call callSet callProperties) {
        for(Iterator iter = callProperties.iterator(); iter.hasNext();) {
            NameValuePairDescriptor next = (NameValuePairDescriptor)
                    iter.next();
            call.setProperty(next.getName(), next.getValue());
        }
    }
                                          Method methodObject[] args)
            throws Throwable {
        Object returnValue = null;
        // Can only be one of : 
        //     boolean java.lang.Object.equals(Object)
        //     int     java.lang.Object.hashCode()
        //     String  java.lang.Object.toString()
        //
        // Optimize by comparing as few characters as possible.
        switchmethod.getName().charAt(0) ) {
            case 'e' :
                Object other = Proxy.isProxyClass(args[0].getClass()) ?
                        Proxy.getInvocationHandler(args[0]) : args[0];
                returnValue = Boolean.valueOf(handler.equals(other));
                break;
            case 'h' :
                returnValue = Integer.valueOf(handler.hashCode());
                break;
            case 't' :
                returnValue = handler.toString();
                break;
            default :
                throw new Throwable("Object method " + method.getName() +
                        "not found");
        }
        return returnValue;
    }
    /* TODO remove me if none of the cts use this
    private void setJBIProperties(Object stubOrCall, ServiceRefPortInfo portInfo) {
        // Check if the target service is a JBI service, and get its QName
        QName svcQName = serviceRef.getServiceName();
        if ( svcQName == null )
            return;
        if ( stubOrCall instanceof Stub ) {
            com.sun.xml.rpc.spi.runtime.StubBase stub =
                    (com.sun.xml.rpc.spi.runtime.StubBase)stubOrCall;
            try {
                // This statement is getting executed only
                //because jbi-enabled property on the stub is set to true
                //TODO BM fix this later
                 ServiceEngineUtil.setJBITransportFactory(portInfo, stub, true);
            } catch(Throwable e) {
                // Do nothing
                //logger.severe("Exception raised while setting transport " +
                //      "factory to NMR : " + e.getMessage());
            }
            return;
        }
    }*/
New to GrepCode? Check out our FAQ X