/*
* 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;
}
}