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.runtime.description.marshal.impl; import org.apache.axis2.description.AxisService; import org.apache.axis2.description.Parameter; import org.apache.axis2.java.security.AccessController; import org.apache.axis2.jaxws.ExceptionFactory; import org.apache.axis2.jaxws.description.EndpointDescription; import org.apache.axis2.jaxws.description.EndpointInterfaceDescription; import org.apache.axis2.jaxws.description.FaultDescription; import org.apache.axis2.jaxws.description.OperationDescription; import org.apache.axis2.jaxws.description.ParameterDescription; import org.apache.axis2.jaxws.description.ServiceDescription; import org.apache.axis2.jaxws.i18n.Messages; import org.apache.axis2.jaxws.runtime.description.marshal.AnnotationDesc; import org.apache.axis2.jaxws.runtime.description.marshal.FaultBeanDesc; import org.apache.axis2.jaxws.utility.ClassUtils; import org.apache.axis2.util.JavaUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import javax.xml.bind.JAXBElement; import java.lang.reflect.Method; import java.security.PrivilegedActionException; import java.security.PrivilegedExceptionAction; import java.util.HashMap; import java.util.Map; /** * Walks the ServiceDescription and its child *Description classes to find all of the types. An * AnnotationDesc is built for each of the types */ public class AnnotationBuilder { private static Log log = LogFactory.getLog(AnnotationBuilder.class); /** This is a static utility class. The constructor is intentionally private */ private AnnotationBuilder() { } /** * @param serviceDescription ServiceDescription * @param ap ArtifactProcessor which found/produced artifact classes * @return AnnotationDesc Map */ public static Map<String, AnnotationDesc> getAnnotationDescs(ServiceDescription serviceDesc, ArtifactProcessor ap) { Map<String, AnnotationDesc> map = new HashMap<String, AnnotationDesc>(); EndpointDescription[] endpointDescs = serviceDesc.getEndpointDescriptions(); // Build a set of packages from all of the endpoints if (endpointDescs != null) { for (int i = 0; i < endpointDescs.length; i++) { getAnnotationDescs(endpointDescs[i], ap, map); } } return map; } /** * @param endpointDesc * @param ap ArtifactProcessor which found/produced artifact classes * @param map */ private static void getAnnotationDescs(EndpointDescription endpointDesc, ArtifactProcessor ap, Map<String, AnnotationDesc> map) { String implClassName = getServiceImplClassName(endpointDesc); if (implClassName != null) { Class clz; clz = loadClass(implClassName); if (clz == null) { clz = loadClass(implClassName, endpointDesc.getAxisService().getClassLoader()); } if (clz != null) { addAnnotation(endpointDesc, clz, map); } } EndpointInterfaceDescription endpointInterfaceDesc = endpointDesc.getEndpointInterfaceDescription(); if (endpointInterfaceDesc != null) { getAnnotationDescs(endpointDesc, endpointInterfaceDesc, ap, map); } } /** * @param endpointInterfaceDesc * @param ap ArtifactProcessor which found/produced artifact classes * @param map */ private static void getAnnotationDescs(EndpointDescription endpointDesc, EndpointInterfaceDescription endpointInterfaceDesc, ArtifactProcessor ap, Map<String, AnnotationDesc> map) { Class clz = endpointInterfaceDesc.getSEIClass(); if (clz != null) { addAnnotation(endpointDesc, clz, map); } // Don't dig into the async operations OperationDescription[] opDescs = endpointInterfaceDesc.getDispatchableOperations(); // Build a set of packages from all of the opertions if (opDescs != null) { for (int i = 0; i < opDescs.length; i++) { getAnnotationDescs(endpointDesc, opDescs[i], ap, map); } } } /** * Get annotations for this operation * * @param opDesc * @param ap ArtifactProcessor which found/produced artifact classes * @param map */ private static void getAnnotationDescs(EndpointDescription endpointDesc, OperationDescription opDesc, ArtifactProcessor ap, Map<String, AnnotationDesc> map) { // Walk the parameter information ParameterDescription[] parameterDescs = opDesc.getParameterDescriptions(); if (parameterDescs != null) { for (int i = 0; i < parameterDescs.length; i++) { getAnnotationDescs(endpointDesc, parameterDescs[i], map); } } // Walk the fault information FaultDescription[] faultDescs = opDesc.getFaultDescriptions(); if (faultDescs != null) { for (int i = 0; i < faultDescs.length; i++) { getAnnotationDescs(endpointDesc, faultDescs[i], ap, map); } } // Also consider the request and response wrappers String wrapperName = ap.getRequestWrapperMap().get(opDesc); if (wrapperName != null) { addAnnotation(endpointDesc, wrapperName, map); } wrapperName = ap.getResponseWrapperMap().get(opDesc); if (wrapperName != null) { addAnnotation(endpointDesc, wrapperName, map); } // Finally consider the result type Class cls = opDesc.getResultActualType(); if (cls != null && cls != void.class && cls != Void.class) { addAnnotation(endpointDesc, cls, map); } } private static void getAnnotationDescs(EndpointDescription endpointDesc, ParameterDescription paramDesc, Map<String, AnnotationDesc> map) { // Get the type that defines the actual data. (this is never a holder ) Class paramClass = paramDesc.getParameterActualType(); if (paramClass != null) { getTypeAnnotationDescs(endpointDesc, paramClass, map); } } /** * Update the package set with the packages referenced by this FaultDescription * * @param faultDesc FaultDescription * @param set Set<Package> that is updated */ private static void getAnnotationDescs(EndpointDescription endpointDesc, FaultDescription faultDesc, ArtifactProcessor ap, Map<String, AnnotationDesc> map) { FaultBeanDesc faultBeanDesc = ap.getFaultBeanDescMap().get(faultDesc); Class faultBean = loadClass(faultBeanDesc.getFaultBeanClassName()); if (faultBean == null) { faultBean = loadClass(faultBeanDesc.getFaultBeanClassName(), endpointDesc.getAxisService().getClassLoader()); } if (faultBean != null) { getTypeAnnotationDescs(endpointDesc, faultBean, map); } } private final static Class[] noClass = new Class[] {}; /** * Get the annotations for this type * * @param cls */ private static void getTypeAnnotationDescs(EndpointDescription endpointDesc, Class cls, Map<String, AnnotationDesc> map) { if (JAXBElement.class.isAssignableFrom(cls)) { try { Method m = cls.getMethod("getValue", noClass); Class cls2 = m.getReturnType(); addAnnotation(endpointDesc, cls2, map); } catch (Exception e) { // We should never get here if (log.isDebugEnabled()) { log.debug("Cannot find JAXBElement.getValue method."); } } } else { addAnnotation(endpointDesc, cls, map); } } private static void addAnnotation(EndpointDescription endpointDesc, String className, Map<String, AnnotationDesc> map) { if (map.get(className) == null) { Class clz = loadClass(className); if (clz == null) { clz = loadClass(className, endpointDesc.getAxisService().getClassLoader()); } if (clz != null) { addAnnotation(endpointDesc, clz, map); } } } private static void addAnnotation(EndpointDescription endpointDesc, Class cls, Map<String, AnnotationDesc> map) { String className = cls.getCanonicalName(); if (map.get(className) == null) { AnnotationDesc desc = AnnotationDescImpl.create(cls); map.put(className, desc); if (cls.isPrimitive()) { Class class2 = ClassUtils.getWrapperClass(cls); AnnotationDesc desc2 = AnnotationDescImpl.create(class2); map.put(class2.getCanonicalName(), desc2); } else { Class class2 = ClassUtils.getPrimitiveClass(cls); if (class2 != null) { AnnotationDesc desc2 = AnnotationDescImpl.create(class2); map.put(class2.getCanonicalName(), desc2); } } // Inspect the interfaces. This is done to pick up other // @XmlSeeAlso usages. Class[] interfaces = cls.getInterfaces(); if (interfaces != null) { for (int i = 0; i < interfaces.length; i++) { addAnnotation(endpointDesc, interfaces[i], map); } } } } /** * Loads the class * * @param className * @return Class (or null if the class cannot be loaded) */ private static Class loadClass(String className, ClassLoader loader) { // Don't make this public, its a security exposure if (className == null || className.length() == 0) { return null; } try { return forName(className, true, loader); //Catch Throwable as ClassLoader can throw an NoClassDefFoundError that //does not extend Exception, so lets catch everything that extends Throwable //rather than just Exception. } catch (Throwable e) { // Depending on the jaxws scenario, it is normal that some classes are not available. if (log.isDebugEnabled()) { log.debug("AnnotationBuilder did not find the following class:" + className); } } return null; } /** * Loads the class * * @param className * @return Class (or null if the class cannot be loaded) */ private static Class loadClass(String className) { // Don't make this public, its a security exposure if (className == null || className.length() == 0) { return null; } try { return forName(className, true, getContextClassLoader()); //Catch Throwable as ClassLoader can throw an NoClassDefFoundError that //does not extend Exception, so lets catch everything that extends Throwable //rather than just Exception. } catch (Throwable e) { // Depending on the jaxws scenario, it is normal that some classes are not available. if (log.isDebugEnabled()) { log.debug("AnnotationBuilder did not find the following class:" + className); } } return null; } /** * Return the class for this name * * @return Class */ static Class forName(final String className, final boolean initialize, final ClassLoader classloader) throws ClassNotFoundException { // NOTE: This method must remain protected because it uses AccessController Class cl = null; try { cl = (Class) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws ClassNotFoundException { // Class.forName does not support primitives Class cls = ClassUtils.getPrimitiveClass(className); if (cls == null) { cls = Class.forName(className, initialize, classloader); } return cls; } }); } catch (PrivilegedActionException e) { /* An exception should NOT be logged. Depending on the JAXWS scenario, certain classes * may or may not exist. Putting an exception in the log will confuse programmers who * are servicing the product * if (log.isDebugEnabled()) { log.debug("Exception thrown from AccessController: " + e); } */ throw (ClassNotFoundException) e.getException(); } return cl; } /** @return ClassLoader */ static ClassLoader getContextClassLoader() { // NOTE: This method must remain private because it uses AccessController ClassLoader cl = null; try { cl = (ClassLoader) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws ClassNotFoundException { return Thread.currentThread().getContextClassLoader(); } }); } catch (PrivilegedActionException e) { if (log.isDebugEnabled()) { log.debug("Exception thrown from AccessController: " + e); } throw (RuntimeException) e.getException(); } return cl; } /** * Get the Serivce Impl Class by looking at the AxisService * @param endpointDescription * @return class name or null */ static private String getServiceImplClassName(EndpointDescription endpointDescription) { String result = null; if (endpointDescription != null) { AxisService as = endpointDescription.getAxisService(); if (as != null) { Parameter param = as.getParameter(org.apache.axis2.Constants.SERVICE_CLASS); // If there was no implementation class, we should not go any further if (param != null) { result = ((String) param.getValue()).trim(); } } } return result; } }