Apache CXF example source code file (Wrapper.java)

This example Apache CXF source code file (Wrapper.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Apache CXF tags/keywords

annotation, class, class, genericarraytype, log, log, logging, message, method, method, operationinfo, parameterizedtype, reflection, string, string, util, webparam, wrapperbeanclass, wrapperbeanclass, xml

The Apache CXF Wrapper.java source code

/**
 * 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.cxf.tools.java2wsdl.processor.internal.jaxws;

import java.lang.annotation.Annotation;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.jws.WebParam;
import javax.xml.namespace.QName;
import javax.xml.ws.Holder;

import org.apache.cxf.common.i18n.Message;
import org.apache.cxf.common.logging.LogUtils;
import org.apache.cxf.common.util.PackageUtils;
import org.apache.cxf.common.util.StringUtils;
import org.apache.cxf.service.model.OperationInfo;
import org.apache.cxf.tools.common.ToolConstants;
import org.apache.cxf.tools.common.ToolException;
import org.apache.cxf.tools.common.model.JavaField;
import org.apache.cxf.tools.java2wsdl.generator.wsdl11.annotator.WrapperBeanAnnotator;
import org.apache.cxf.tools.java2wsdl.generator.wsdl11.annotator.WrapperBeanFieldAnnotator;
import org.apache.cxf.tools.java2wsdl.generator.wsdl11.model.WrapperBeanClass;
import org.apache.cxf.tools.util.AnnotationUtil;
import org.apache.cxf.tools.util.NameUtil;
import org.apache.cxf.tools.util.URIParserUtil;


public class Wrapper {
    private static final Logger LOG = LogUtils.getL7dLogger(Wrapper.class);
    private QName name;
    private WrapperBeanClass javaClass;
    private Method method;
    private boolean isSamePackage;

    private OperationInfo operationInfo;
    private String className;

    public void setOperationInfo(final OperationInfo op) {
        this.operationInfo = op;
        setMethod((Method) op.getProperty("operation.method"));
    }

    public void setMethod(Method m) {
        this.method = m;
    }

    public void setName(QName n) {
        this.name = n;
    }
    public void setClassName(String s) {
        className = s;
    }
    public String getClassName() {
        return className;
    }

    public WrapperBeanClass getWrapperBeanClass(final Method m) {
        return new WrapperBeanClass();
    }
    
    protected WrapperBeanClass getWrapperBeanClass(final QName wrapperBeanName) {
        WrapperBeanClass jClass = new WrapperBeanClass();
        if (wrapperBeanName == null) {
            return jClass;
        }
        String ns = wrapperBeanName.getNamespaceURI();
        jClass.setNamespace(ns);
        jClass.setPackageName(URIParserUtil.getPackageName(ns));
        jClass.setName(NameUtil.mangleNameToClassName(wrapperBeanName.getLocalPart()));
        jClass.setElementName(wrapperBeanName);
        return jClass;
    }

    private WrapperBeanClass merge(final WrapperBeanClass c1, final WrapperBeanClass c2) {
        if (c1.getElementName() == null) {
            c1.setElementName(c2.getElementName());
        }

        if (StringUtils.isEmpty(c1.getNamespace())) {
            c1.setNamespace(c2.getNamespace());
        }

        if (StringUtils.isEmpty(c1.getPackageName())) {
            c1.setPackageName(c2.getPackageName());
        } else {
            this.isSamePackage = c1.getPackageName().equals(c2.getPackageName());
        }


        if (StringUtils.isEmpty(c1.getName())) {
            c1.setName(c2.getName());
        }       
        return c1;
    }
    
    public WrapperBeanClass getJavaClass() {
        if (javaClass == null) {
            WrapperBeanClass jClass1 = getWrapperBeanClass(this.name);
            WrapperBeanClass jClass2 = getWrapperBeanClass(this.method);
            javaClass = merge(jClass2, jClass1);
        }
        return javaClass;
    }

    public WrapperBeanClass buildWrapperBeanClass() {
        WrapperBeanClass jClass = getJavaClass();
        List<JavaField> fields = buildFields();
        for (JavaField field : fields) {
            field.setOwner(jClass);
            field.annotate(new WrapperBeanFieldAnnotator());
            jClass.addField(field);
            jClass.appendGetter(field);
            jClass.appendSetter(field);
        }
        jClass.annotate(new WrapperBeanAnnotator());
        return jClass;
    }

    protected String getPackageName(final Method m) {
        String pkg = PackageUtils.getPackageName(m.getDeclaringClass());
        return pkg.length() == 0 ? ToolConstants.DEFAULT_PACKAGE_NAME : pkg;
    }

    public boolean isWrapperAbsent() {
        return isWrapperAbsent(this.method);
    }

    public boolean isWrapperAbsent(final Method m) {
        return false;
    }

    public boolean isWrapperBeanClassNotExist() {
        try {
            Message msg = new Message("LOADING_WRAPPER_CLASS", LOG, getJavaClass().getFullClassName());
            LOG.log(Level.FINE, msg.toString());
            getWrapperClass();
            return false;
        } catch (ToolException e) {
            return true;
        }
    }

    public boolean isToDifferentPackage() {
        return !isSamePackage;
    }

    public Class getWrapperClass() {
        try {
            return AnnotationUtil.loadClass(getJavaClass().getFullClassName(),
                                            getClass().getClassLoader());
        } catch (Exception e) {
            Message msg = new Message("LOAD_WRAPPER_CLASS_FAILED", LOG, getJavaClass().getFullClassName());
            LOG.log(Level.FINE, msg.toString());
            throw new ToolException(msg);
        }
    }

    protected boolean isBuiltInTypes(Class<?> clz) {
        if (clz == null || clz.isPrimitive()) {
            return true;
        }
        return "java.lang".equals(clz.getPackage().getName());
    }
    
    protected List<JavaField> buildFields() {
        return new ArrayList<JavaField>();
    }

    public Method getMethod() {
        return this.method;
    }

    public OperationInfo getOperationInfo() {
        return this.operationInfo;
    }
    
    protected String getTypeString(Type t) {
        String type = "Object";
        if (t instanceof Class) {
            Class clz = (Class) t;
            if (clz.isArray()) {
                if (isBuiltInTypes(clz.getComponentType())) {
                    type = clz.getComponentType().getSimpleName() + "[]";
                } else {
                    type = clz.getComponentType().getName() + "[]";
                }
            } else {
                type = clz.getName();
            }
        } else if (t instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) t;
            Class c = (Class)pt.getRawType();
            if (Holder.class.isAssignableFrom(c)
                && pt.getActualTypeArguments().length == 1
                && pt.getActualTypeArguments()[0] instanceof Class) {
                type = getTypeString(pt.getActualTypeArguments()[0]);
            } else {
                type = t.toString();
            }
        } else if (t instanceof GenericArrayType) {
            GenericArrayType gat = (GenericArrayType)t;
            type = gat.toString();
        }
        type = type.replace('$', '.');
        return type;
    }
    
    protected WebParam getWebParamAnnotation(final Annotation[] annotations) {
        for (Annotation annotation : annotations) {
            if (annotation instanceof WebParam) {
                return (WebParam)annotation;
            }
        }
        return null;
    }

}