Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.atlassian.xmlrpc;
  
  /*
   * 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.
  */
 import java.util.List;
 import java.util.Map;
java.lang.reflect.InvocationHandler for the XML-RPC service object proxy

Author(s):
jdumay
 
 public final class XmlRpcInvocationHandler implements InvocationHandler
 {
 
     public XmlRpcInvocationHandler(XmlRpcClientProvider clientProvider)
     {
         this. = clientProvider;
     }

    
Extracts the XML-RPC method name from the java.lang.reflect.Method

Parameters:
method
Returns:
methodName
 
     protected String getMethodName(Method method)
     {
         String methodName = method.getName();
         ServiceMethod serviceMethod = method.getAnnotation(ServiceMethod.class);
         if (serviceMethod != null && serviceMethod.value() != null)
         {
             methodName = serviceMethod.value();
         }
         return methodName;
     }

    
Converts arguments from an array of objects to a java.util.Vector and converts any java.util.Collection's to an Array

Parameters:
objects
Returns:
 
     protected Vector convertArguments(Object[] objects)
     {
         //When there are no arguments to the method
         if (objects == null)
         {
             return new Vector();
         }
 
         final ArrayList args = new ArrayList();
         for (Object o : objects)
         {
             if (o instanceof Collection)
             {
                 args.add(((Collectiono).toArray());
             }
             else
             {
                 args.add(o);
             }
         }
         return new Vector(args);
     }

    
Converts the return value of a method to a ServiceBean marked object (if metadata is available)

Parameters:
method
returnValue
Returns:
returnValue converted value
Throws:
java.lang.InstantiationException
java.lang.IllegalAccessException
java.lang.reflect.InvocationTargetException
    protected Object convertReturnValue(Method methodObject returnValue)
    {
        if (returnValue == null)
        {
            return null;
        }
        final Class beanType = getReturnBeanType(method);
        Collection collection = null;
        if (returnValue.getClass().isArray())
        {
            Object[] objArray = (Object[]) returnValue;
            collection = new ArrayList(Arrays.asList(objArray));
            if (beanType != null)
            {
                collection = mapBeanCollection(collectionbeanType);
            }
            return collection;
        }
        else if (Collection.class.isAssignableFrom(returnValue.getClass()))
        {
            collection = (Collection)returnValue;
            if (beanType != null)
            {
                collection = mapBeanCollection(collectionbeanType);
            }
            return collection;
        }
        else if (Map.class.isAssignableFrom(returnValue.getClass()) && beanType != null)
        {
            returnValue = mapBean((MapreturnValuebeanType);
        }
        return returnValue;
    }
    public Object invoke(Object proxyMethod methodObject[] argsthrows Throwable
    {
        final String serviceName = getServiceName(method);
        final String methodName = getMethodName(method);
        try
        {
            Object returnValue = .execute(serviceNamemethodNameconvertArguments(args));
            returnValue = convertReturnValue(methodreturnValue);
            //If the return type is null and method return typoe is void we shouldn't return any value
            if (returnValue != null && !method.getReturnType().equals(Void.class))
            {
                return returnValue;
            }
            return .;
        }
        catch (Exception e)
        {
            throw new RuntimeException("Could not execute RPC method " + methodNamee);
        }
    }
    private String getServiceName(Method method)
    {
        ServiceObject serviceObject = method.getDeclaringClass().getAnnotation(ServiceObject.class);
        return serviceObject.value();
    }
    private Class getReturnBeanType(Method method)
    {
        //Check if the return type is the service bean
        if (method.getReturnType().isAnnotationPresent(ServiceBean.class))
        {
            return method.getReturnType();
        }
        //Check if the return bean type is a generic parameter of a different type
        Type type = method.getGenericReturnType();
        if (type instanceof ParameterizedType)
        {
            ParameterizedType typeParam = (ParameterizedTypetype;
            if (typeParam.getActualTypeArguments().length == 1)
            {
                Type resultType = typeParam.getActualTypeArguments()[0];
                if (resultType instanceof Class)
                {
                    Class returnType = (ClassresultType;
                    if (returnType.isAnnotationPresent(ServiceBean.class))
                    {
                        return returnType;
                    }
                }
            }
        }
        return null;
    }
    private ArrayList mapBeanCollection(Collection<MapresultClass beanType)
    {
        ArrayList beanCollection = new ArrayList();
        for (Map map : result)
        {
            final Object beanInstance = mapBean(mapbeanType);
            beanCollection.add(beanInstance);
        }
        return beanCollection;
    }
    private Object mapBean(Map mapClass beanType)
    {
        Object beanInstance = beanType.newInstance();
        mapToBean(beanInstancemap);
        return beanInstance;
    }
    private void mapToBean(Object beanMap map)
            throws IllegalAccessExceptionInvocationTargetException
    {
        BeanUtils.populate(beanremoveNullValues(mapArraysToLists(remapPropertyNames(beanmap))));
    }
    private Map mapArraysToLists(Map<StringObjectmap)
    {
        Map<StringObjectresult = new HashMap<StringObject>(map);
        for (String key : result.keySet())
        {
            Object value = result.get(key);
            if (value != null && value.getClass().isArray())
            {
                result.put(key, Arrays.asList((Object[]) value));
            }
            else
            {
                result.put(keyvalue);
            }
        }
        return result;
    }
    private Map removeNullValues(Map<StringObjectmap)
    {
        Map<StringObjectresult = new HashMap<StringObject>();
        for (String key : map.keySet())
        {
            final Object value = map.get(key);
            /*
             Nil values may be returned as empty strings from some XML-RPC servers
             Until we have some nice way of abstracting the type conversion out on
             a per binder impl basis this hack will have todo
            */
            final boolean isString = value instanceof String;
            final boolean isEmptyString = isString && value.toString().equals("");
            if (value != null && !isEmptyString)
            {
                result.put(keyvalue);
            }
        }
        return result;
    }
    private Map remapPropertyNames(Object beanMap map)
    {
        Map result = new HashMap(map);
        for (PropertyDescriptor descriptor : PropertyUtils.getPropertyDescriptors(bean))
        {
            Method writeMethod = descriptor.getWriteMethod();
            if (writeMethod != null)
            {
                ServiceBeanField beanField = writeMethod.getAnnotation(ServiceBeanField.class);
                if (beanField != null && beanField.value() != null && !beanField.value().equals(""))
                {
                    Object data = result.get(beanField.value());
                    result.remove(beanField.value());
                    result.put(descriptor.getName(), data);
                }
                else
                {
                    result.put(descriptor.getName(), map.get(descriptor.getName()));
                }
            }
        }
        return result;
    }
New to GrepCode? Check out our FAQ X