/**
    * Copyright By Grandsoft Company Limited.  
    * 2014年3月10日 下午6:31:36
    */
   package gboat2.cxf.utils;
   
   import gboat2.base.bridge.exception.DefaultGboatNestedException;
   import gboat2.base.bridge.util.json.JsonUtil;
   import gboat2.base.bridge.util.xml.JAXBUtil;
  
  import java.util.ArrayList;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  
  import javax.xml.bind.annotation.XmlRootElement;
  import javax.xml.namespace.QName;
  
  import org.apache.commons.collections.MapUtils;
  import org.apache.commons.lang3.ArrayUtils;
  import org.apache.commons.lang3.ClassUtils;
  import org.apache.cxf.common.jaxb.JAXBUtils;
  import org.apache.cxf.common.jaxb.JAXBUtils.IdentifierType;
  import org.apache.cxf.endpoint.Client;
  import org.apache.cxf.endpoint.Endpoint;
  import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;
  import org.apache.cxf.service.model.BindingInfo;
  import org.apache.cxf.service.model.BindingMessageInfo;
  import org.apache.cxf.service.model.BindingOperationInfo;
  import org.apache.cxf.service.model.MessagePartInfo;
  import org.apache.cxf.transport.http.HTTPConduit;
  import org.apache.cxf.transports.http.configuration.HTTPClientPolicy;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.BeanUtils;
  import org.springframework.beans.BeansException;
  import org.springframework.util.Assert;
  
  /**
   * <p>
   * 使用 CXF 发布 WebService 服务和调用 WebService 服务的工具类。<br>
   * <small><b>注：</b>目前只提供了调用 WebService 服务相关的方法，而没提供发布服务相关的方法</small><br>
   * </p>
   * 该工具类解决了在 OSGI 环境中直接使用 CXF wsdl2java 生成的代码调用 WebService 时的以下问题：
   * <ol>
   * <li>传递复杂对象时，会抛出“<i>javax.xml.ws.WebServiceException: Could not find
   * wsdl:binding operation info for web method ...</i>”的异常</li>
   * <li>当 WebService 服务端的接口和实现类在不同的包下，而且实现类没指定 {@code @WebService} 注解的
   * {@code targetNamespace}
   * 属性时，会抛出“<i>org.apache.cxf.common.i18n.UncheckedException: No operation was
   * found with the name ...</i>”的异常。</li>
   * </ol>
   * 传递复杂参数（JavaBean）调用 WebService 服务的步骤：
   * <ol>
   * <li>使用 CXF 的 wsdl2java 工具生成 Java 代码；</li>
   * <li>使用刚才生成的 JavaBean 创建对象实例，并赋值；</li>
   * <li>调用本工具类的 {@link #invokeWebService(String, String, Object...)} 方法，将刚才创建的
   * JavaBean 实例作为参数传入；</li>
   * <li>如果返回结果中包含复杂对象（JavaBean），则可以通过 Spring 的 {@link BeanUtils} 或
   * commons-beanutils 的 {@link org.apache.commons.beanutils.BeanUtils BeanUtils}
   * 工具类将返回结果转换成刚才通过 wsdl2java 生成的 JavaBean，或是通过 json 工具进行转换（先将结果中的 JavaBean 转换成
   * json 字符串，再将 json 字符串转换成自己的 JavaBean），这样就可以更方便的读取返回结果中的具体信息了。</li>
   * </ol>
   * 
   * @author <a href="mailto:[email protected]">何明旺</a>
   * @since 3.0
   * @date 2014年3月10日
   */
  public class CXFUtil {
  
      private final static Logger logger = LoggerFactory.getLogger(CXFUtil.class);
      private final static int CONFIGURE_CLIENT_SIZE = 999999999;
  
      /**
       * 将构造方法设为私有，防止在外部被实例化
       */
      private CXFUtil() {
      }
      
      /**
       * 动态创建 WebService 的 JAX-WS 方式调用客户端实例<br>
       * 和直接执行 {@code createJaxWsDynamicClient(wsdlUrl, JaxWsDynamicClientFactory.class.getClassLoader())} 返回的结果一样
       * @param wsdlUrl WSDL 地址
       * @return
       */
      public static Client createJaxWsDynamicClient(String wsdlUrl){
          return createJaxWsDynamicClient(wsdlUrl, JaxWsDynamicClientFactory.class.getClassLoader());
      }
      
      /**
       * 动态创建 WebService 的 JAX-WS 方式调用客户端实例
       * @param wsdlUrl WSDL 地址
       * @param classLoader 类加载器，调用 CXF 的
       *            {@link org.apache.cxf.endpoint.dynamic.DynamicClientFactory#createClient(String, ClassLoader)
       *            DynamicClientFactory#createClient(String, ClassLoader)} 方法动态创建客户端时，将使用此类加载器
       * @return
       */
      public static Client createJaxWsDynamicClient(String wsdlUrl, ClassLoader classLoader) {
          // 创建 HttpClient 策略
         HTTPClientPolicy httpClientPolicy = new HTTPClientPolicy();
         httpClientPolicy.setAllowChunking(false);
         httpClientPolicy.setChunkingThreshold(CONFIGURE_CLIENT_SIZE);
 
         // 动态创建 WebService 客户端
         Client client = JaxWsDynamicClientFactory.newInstance().createClient(wsdlUrl, classLoader);
         ((HTTPConduit) client.getConduit()).setClient(httpClientPolicy);
         return client;
     }
     
     /**
      * 获取 CXF 的绑定操作信息的实例
      * @param client CXF 客户端，可通过 {@link #createJaxWsDynamicClient(String)} 进行创建
      * @param operation 操作名称（一般和方法名相同），如： sayHello
      * @return 绑定操作信息的实例。如果没有找到对应的绑定操作，则返回 <code>null</code>
      */
     public static BindingOperationInfo getBindingOperationInfo(Client client, String operation){
         Endpoint endpoint = client.getEndpoint();  
         BindingInfo bindingInfo = endpoint.getEndpointInfo().getBinding();  
         QName opName = new QName(endpoint.getService().getName().getNamespaceURI(), operation);  
         BindingOperationInfo boi = bindingInfo.getOperation(opName);
         if (boi == null) { // WebService 接口和实现类的 namespace 不相同的情况
             for (BindingOperationInfo operationInfo : bindingInfo.getOperations()) {
                 if (operation.equals(operationInfo.getName().getLocalPart())) {
                     return operationInfo;
                 }
             }
         }
         return boi;
     }
 
     /**
      * 获取操作对象的输入参数
      * @param boi 操作对象
      * @return 操作的输入参数 Map，key 为参数的名称，value 为参数的类型
      */
     public static Map<String, Class<?>> getInputParameters(BindingOperationInfo operationInfo) {
         return getParameters(operationInfo, true);
     }
     
     /**
      * 获取操作对象的输出参数
      * @param boi 操作对象
      * @return 操作的输出参数 Map，key 为参数的名称，value 为参数的类型
      */
     public static Map<String, Class<?>> getOutputParameters(BindingOperationInfo operationInfo) {
         return getParameters(operationInfo, false);
     }
     
     /**
      * 获取操作对象的输入或输出参数
      * @param boi 操作对象
      * @param input true 表示获取输入参数，false 表示获取输出参数
      * @return 操作的指定类型参数 Map，key 为参数的名称，value 为参数的类型
      */
     private static Map<String, Class<?>> getParameters(BindingOperationInfo boi, boolean input) {
         BindingOperationInfo unWrappedBoi = boi.isUnwrapped() ? boi : boi.getUnwrappedOperation();
         BindingMessageInfo bmi = (input ? unWrappedBoi.getInput() : unWrappedBoi.getOutput());
         List<MessagePartInfo> messageParts = bmi.getMessageParts();
         Map<String, Class<?>> result = new LinkedHashMap<String, Class<?>>(messageParts.size());
         for (MessagePartInfo mpi : messageParts) {
             result.put(mpi.getName().getLocalPart(), mpi.getTypeClass());
         }
         return result;
     }
     
     /**
      * 调用 webservice 服务<br>
      * 和直接执行
      * {@code invokeWebService(wsdlUrl, operation, JaxWsDynamicClientFactory.class.getClassLoader(), parameters)}
      * 返回的结果一样
      * @param wsdlUrl WSDL 地址
      * @param operation 要调用的操作（WebService 服务名称）
      * @param parameters 参数列表，如果没有参数，则可以不传入该参数值
      * @return WebService 服务端返回的结果
      * @see #invokeWebService(String, String, ClassLoader, Object...)
      */
     public static Object[] invokeWebService(String wsdlUrl, String operation, Object... parameters) {
         return invokeWebService(wsdlUrl, operation, JaxWsDynamicClientFactory.class.getClassLoader(), parameters);
     }
 
     /**
      * 调用 webservice 服务
      * 
      * @param wsdlUrl WSDL 地址
      * @param operation 要调用的操作（WebService 服务名称）
      * @param classLoader 类加载器，调用 CXF 的
      *            {@link org.apache.cxf.endpoint.dynamic.DynamicClientFactory#createClient(String, ClassLoader)
      *            DynamicClientFactory#createClient(String, ClassLoader)} 方法动态创建客户端时，将使用此类加载器
      * @param parameters 参数列表，如果没有参数，则可以不传入该参数值
      * @return WebService 服务端返回的结果
      */
     public static Object[] invokeWebService(String wsdlUrl, String operation,
             ClassLoader classLoader, Object... parameters) {
         // 动态创建 WebService 客户端
         Client client = createJaxWsDynamicClient(wsdlUrl, classLoader);
         // 调用 WebService 服务
         return invokeWebService(client, operation, parameters);
     }
     
     /**
      * 调用 webservice 服务
      * @param client WebService 客户端实例对象
      * @param operation 要调用的操作（WebService 服务名称）
      * @param parameters 参数列表，如果没有参数，则可以不传入该参数值
      * @return 服务端返回的结果
      */
     public static Object[] invokeWebService(Client client, String operation, Object... parameters) {
         try {
             BindingOperationInfo boi = getBindingOperationInfo(client, operation);
             if(boi == null)
                 throw new DefaultGboatNestedException(
                         "No operation was found with the name [" + operation + "] of namespace "
                                 + client.getEndpoint().getService().getName().getNamespaceURI());
             
             if(!boi.isUnwrapped()) {
                 boi = boi.getUnwrappedOperation();
             }
             // WebService 服务需要的输入参数的信息
             Map<String,Class<?>> inputParamInfoMap = getInputParameters(boi);
             if(ArrayUtils.isNotEmpty(parameters) && MapUtils.isNotEmpty(inputParamInfoMap)) {
                 List<Class<?>> needTypes = new ArrayList<Class<?>>(inputParamInfoMap.values());
                 Class<?> needType = null; // 需要的类型
                 Class<?> actualType = null; // 实际传入的类型
                 for (int i = 0, size = needTypes.size(); i < size; i++) {
                     // 如果实际传入的参数个数小于需要的参数个数，且实际传入的参数已经全部被处理完成，则中止循环
                     if(i >= parameters.length)
                         break;
                     
                     // 如果当前参数值为 null，则什么也不做，直接跳过
                     if(parameters[i] == null)
                         continue;
                     
                     needType = needTypes.get(i);
                     actualType = parameters[i].getClass();
                     // 如果当前参数值为原生类型或者可以强转为需要的参数类型，则什么也不做，直接跳过
                     if(ClassUtils.isPrimitiveOrWrapper(actualType) || needType.isAssignableFrom(actualType))
                         continue;
                     
                     // 使用需要的类型创建一个新的对象实例，并将当前参数的属性值复制给新创建的实例
                     Object obj = null;
                     try {
                         obj = needType.newInstance();
                         BeanUtils.copyProperties(parameters[i], obj);
                     } catch (BeansException e) {
                         logger.warn(
                                 "通过 CXF 调用 WebService [{}] 时，将第 [{}] 个参数 [{}] 的属性值复制给目标类型的对象 [{}] 失败，将改用 JSON 转换的方式将其转换为目标类型。",
                                 boi, i, actualType, needType);
                         // 如果直接复制失败，则先将源对象转换成 Json 字符串，然后再将 Json 字符串转换成目标对象
                         String json = JsonUtil.object2Json(parameters[i]);
                         obj = JsonUtil.json2Object(json, needType);
                     }
                     parameters[i] = obj;
                 }
             }
             
             // 调用 WebService 服务
             return client.invoke(boi, parameters);
         } catch (Exception e) {
             throw new DefaultGboatNestedException("使用 CXF 动态调用 WebService 服务 [" + operation + "] 失败", e);
         }
     }
 
     /**
      * 调用 WebService 服务
      * 
      * @param wsdlUrl WSDL 地址
      * @param parameter 经过包装后的请求参数，与 WSDL 文件中 &lt;wsdl:operation name="xxx"&gt;
      *            相对应的 JavaBean，该类必须有 &#64;XmlRootElement 注解，&#64;XmlRootElement
      *            注解的 name 属性对应 WSDL 文件中 operation 的 name
      * @return WebService 服务端的返回结果
      */
     public static Object[] invokeWrappedWebService(String wsdlUrl, Object parameter){
         return invokeWrappedWebService(wsdlUrl, parameter, JaxWsDynamicClientFactory.class.getClassLoader());
     }
     
     /**调用 WebService 服务
      * 
      * @param wsdlUrl WSDL 地址
      * @param parameter 经过包装后的请求参数，与 WSDL 文件中 &lt;wsdl:operation name="xxx"&gt;
      *            相对应的 JavaBean，该类必须有 &#64;XmlRootElement 注解，&#64;XmlRootElement
      *            注解的 name 属性对应 WSDL 文件中 operation 的 name
      * @param classLoader 类加载器，调用 CXF 的
      *            {@link org.apache.cxf.endpoint.dynamic.DynamicClientFactory#createClient(String, ClassLoader)
      *            DynamicClientFactory#createClient(String, ClassLoader)} 方法动态创建客户端时，将使用此类加载器
      * @return WebService 服务端的返回结果
      */
     public static Object[] invokeWrappedWebService(String wsdlUrl, Object parameter, ClassLoader classLoader){
         // 动态创建 WebService 客户端
         Client client = createJaxWsDynamicClient(wsdlUrl, classLoader);
         // 调用 WebService 服务
         return invokeWrappedWebService(client, parameter);
     }
     
     /**
      * 调用 WebService 服务
      * 
      * @param client WebService 客户端实例对象
      * @param parameter 经过包装后的请求参数，与 WSDL 文件中 &lt;wsdl:operation name="xxx"&gt;
      *            相对应的 JavaBean，该类必须有 &#64;XmlRootElement 注解，&#64;XmlRootElement
      *            注解的 name 属性对应 WSDL 文件中 operation 的 name
      * @return WebService 服务端的返回结果
      */
     public static Object[] invokeWrappedWebService(Client client, Object parameter) {
         Assert.notNull(parameter, "使用经过 CXF 包装后客户端调用 WebService 失败，原因：传入的参数不能为 null");
         
         Class<?> paramType = parameter.getClass();
         XmlRootElement xmlRootElement = paramType.getAnnotation(XmlRootElement.class);
         Assert.notNull(xmlRootElement, "使用经过 CXF 包装后客户端调用 WebService 失败，原因：传入的参数类型 [" + paramType + "] 必须有 javax.xml.bind.annotation.XmlRootElement 注解");
         
         String operation = xmlRootElement.name();
         if("##default".equals(operation)) {
             operation = paramType.getSimpleName();
         }
         
         try {
             BindingOperationInfo boi = getBindingOperationInfo(client, operation);
             if(boi == null)
                 throw new DefaultGboatNestedException(
                         "No operation was found with the name [" + operation + "] of namespace " + client.getEndpoint().getService().getName().getNamespaceURI());
 
             QName qname = boi.getName();
             String packageName = JAXBUtils.namespaceURIToPackage(qname.getNamespaceURI());
             String simpleClassName = JAXBUtils.nameToIdentifier(qname.getLocalPart(), IdentifierType.CLASS);
             String className = packageName + "." + simpleClassName;
 
             // CXF 动态生成的客户端方法需要的参数类型
             Class<?> needType = Thread.currentThread().getContextClassLoader().loadClass(className);
             if(!needType.isAssignableFrom(paramType)){
                 // 将当前传入的参数转换成与需要的类型相匹配
                 parameter = JAXBUtil.castClone(parameter, needType);
             }
             
             // 调用 WebService 服务
             return client.invoke(boi, parameter);
         } catch (Exception e) {
             throw new DefaultGboatNestedException("使用经过 CXF 包装后客户端调用 WebService [" + operation + "] 失败", e);
         }
     }
 
 }