modules/jaxws/src/org/apache/axis2/jaxws/ExceptionFactory.java - axis-axis2-java-rampart - Git at Google

 /*
  * Copyright 2004,2005 The Apache Software Foundation.
  * Copyright 2006 International Business Machines Corp.
  *
  * Licensed 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;

 import java.lang.reflect.InvocationTargetException;

 import javax.xml.ws.ProtocolException;
 import javax.xml.ws.WebServiceException;
 import javax.xml.ws.http.HTTPException;
 import javax.xml.ws.soap.SOAPFaultException;

 import org.apache.axis2.AxisFault;
 import org.apache.axis2.jaxws.i18n.Messages;
 import org.apache.axis2.jaxws.message.MessageException;
 import org.apache.axis2.jaxws.message.MessageInternalException;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

 /**
   * ExceptionFactory is used to create exceptions within the JAX-WS implementation.
   * There are several reasons for using a factory to create exceptions.
   *    1. We can intercept all exception creation and add the appropriate logging/serviceability.
   *    2. Exceptions are chained.  ExceptionFactory can lengthen or reduce the cause chains as
   *       necessary to support the JAX-WS programming model.
   *    3. Prevents construction of the same exception.  Uses similar principles as AxisFault.makeException.
   *
   * Example Usage:
   *          // Example usage
   *
   *          public fooMethod() throws WebServiceException {
   *             try{
   *                ...
   *             }
   *             catch(Exception e){
   *                throw ExceptionFactory.makeWebServiceException(e);
   *             }
   *          }
   *
   *
   */
 public class ExceptionFactory {

 	 protected static Log log =
 	        LogFactory.getLog(ExceptionFactory.class.getName());

 	/**
 	 * Private Constructor
 	 * All methods are static.  The private constructor prevents instantiation.
 	 */
 	private ExceptionFactory() {
 	}

 	/**
 	 * Create a WebServiceException using the information from a given Throwable instance
 	 * and message
 	 * @param message
 	 * @param throwable
 	 * @return WebServiceException
 	 */
 	public static WebServiceException makeWebServiceException(String message, Throwable throwable) {
 		try {
 			// See if there is already a WebServiceException (Note that the returned exception could be a ProtocolException or
 			// other kind of exception)
 			WebServiceException e = (WebServiceException) findException(throwable, WebServiceException.class);
 			if (e == null) {
 				e = createWebServiceException(message, throwable);
 			}
 			return e;
 		} catch (RuntimeException re) {
 			// TODO
 			// This is not a good situation, an exception occurred while building the exception.
 			// This should never occur!  For now log the problem and rethrow...we may revisit this later
 			if (log.isDebugEnabled()) {
 				log.debug(Messages.getMessage("exceptionDuringExceptionFlow"), re);
 			}
 			throw re;
 		}
 	}

 	/**
 	 * Create a ProtocolException using the information from a Throwable and message
 	 * @param message
 	 * @param throwable
 	 * @return ProtocolException
 	 */
 	public static ProtocolException makeProtocolException(String message, Throwable throwable) {
 		try {
 			// See if there is already a ProtocolException
 			ProtocolException e = (ProtocolException) findException(throwable, ProtocolException.class);
 			if (e == null) {
 				e = createProtocolException(message, throwable);
 			}
 			return e;
 		} catch (RuntimeException re) {
 			// TODO
 			// This is not a good situation, an exception occurred while building the exception.
 			// This should never occur!  For now log the problem and rethrow...we may revisit this later
 			if (log.isDebugEnabled()) {
 				log.debug(Messages.getMessage("exceptionDuringExceptionFlow"), re);
 			}
 			throw re;
 		}
 	}

 	/**
 	 * Create a MessageException using the information from a Throwable and message
 	 * @param message
 	 * @param throwable
 	 * @return MessageException
 	 */
 	public static MessageException makeMessageException(String message, Throwable throwable) {
 		try {
 			// See if there is already a MessgeException
 			MessageException e = (MessageException) findException(throwable, MessageException.class);
 			if (e == null) {
 				e = createMessageException(message, throwable);
 			}
 			return e;
 		} catch (RuntimeException re) {
 			// TODO
 			// This is not a good situation, an exception occurred while building the exception.
 			// This should never occur!  For now log the problem and rethrow...we may revisit this later
 			if (log.isDebugEnabled()) {
 				log.debug(Messages.getMessage("exceptionDuringExceptionFlow"), re);
 			}
 			throw re;
 		}
 	}

 	/**
 	 * Create a MessageInternalException using the information from a Throwable and message
 	 * @param message
 	 * @param throwable
 	 * @return MessageInternalException
 	 */
 	public static MessageInternalException makeMessageInternalException(String message, Throwable throwable) {
 		try {
 			// See if there is already a HTTPException
 			MessageInternalException e = (MessageInternalException) findException(throwable, MessageInternalException.class);
 			if (e == null) {
 				e = createMessageInternalException(message, throwable);
 			}
 			return e;
 		} catch (RuntimeException re) {
 			// TODO
 			// This is not a good situation, an exception occurred while building the exception.
 			// This should never occur!  For now log the problem and rethrow...we may revisit this later
 			if (log.isDebugEnabled()) {
 				log.debug(Messages.getMessage("exceptionDuringExceptionFlow"), re);
 			}
 			throw re;
 		}
 	}

 	/**
 	 * Make a WebServiceException with a given message
 	 * @param message
 	 * @return WebServiceException
 	 */
 	public static WebServiceException makeWebServiceException(String message) {
 		return makeWebServiceException(message, null);
 	}

 	/**
 	 * Create a WebServiceException using the information from a given Throwable instance
 	 * @param throwable
 	 * @return WebServiceException
 	 */
 	public static WebServiceException makeWebServiceException(Throwable throwable){
 		return makeWebServiceException(null, throwable);
 	}

 	/**
 	 * Create a MessageException using the information from a given Throwable instance
 	 * @param throwable
 	 * @return MessageException
 	 */
 	public static MessageException makeMessageException(Throwable throwable){
 		return makeMessageException(null, throwable);
 	}

 	/**
 	 * Make a MessageException with a given message
 	 * @param message
 	 * @return MessageException
 	 */
 	public static MessageException makeMessageException(String message) {
 		return makeMessageException(message, null);
 	}

 	/**
 	 * Create a WebServiceException
 	 * @param message
 	 * @param t Throwable
 	 * @return WebServiceException
 	 */
 	private static WebServiceException createWebServiceException(String message, Throwable t) {
 		Throwable rootCause = null;
 		if (t != null) {
 			rootCause = getRootCause(t);
 		}
 		WebServiceException e = new WebServiceException(message, t);
 		if (log.isDebugEnabled()) {
 			log.debug("Create Exception:", e);
 		}
 		return e;
 	}

 	/**
 	 * Create a ProtocolException
 	 * @param message
 	 * @param t Throwable
 	 * @return ProtocolException
 	 */
 	private static ProtocolException createProtocolException(String message, Throwable t) {
 		Throwable rootCause = null;
 		if (t != null) {
 			rootCause = getRootCause(t);
 		}
 		ProtocolException e = new ProtocolException(message, t);
 		if (log.isDebugEnabled()) {
 			log.debug("create Exception:", t);
 		}
 		return e;
 	}

 	/**
 	 * Create a MessageException
 	 * @param message
 	 * @param t Throwable
 	 * @return MessageException
 	 */
 	private static MessageException createMessageException(String message, Throwable t) {
 		Throwable rootCause = null;
 		if (t != null) {
 			rootCause = getRootCause(t);
 		}
 		MessageException e = new MessageException(message, t);
 		if (log.isDebugEnabled()) {
 			log.debug("create Exception:", t);
 		}
 		return e;
 	}

 	/**
 	 * Create a MessageInternalException
 	 * @param message
 	 * @param t Throwable
 	 * @return MessageException
 	 */
 	private static MessageInternalException createMessageInternalException(String message, Throwable t) {
 		Throwable rootCause = null;
 		if (t != null) {
 			rootCause = getRootCause(t);
 		}
 		MessageInternalException e = new MessageInternalException(message, t);
 		if (log.isDebugEnabled()) {
 			log.debug("create Exception:", t);
 		}
 		return e;
 	}

     /**
      * Return the exception or nested cause that is assignable from the specified class
      * @param t Throwable
      * @param cls
      * @return Exception or null
      */
     private static Exception findException(Throwable t, Class cls) {
     	while(t != null) {
     		if (cls.isAssignableFrom(t.getClass())) {
                 return (Exception) t;
     		}
     		t = getCause(t);
     	}
     	return null;
     }

     /**
      * Gets the Throwable cause of the Exception.  Some exceptions
      * store the cause in a different field, which is why this method
      * should be used when walking the causes.
      * @param t Throwable
      * @return Throwable or null
      */
     private static Throwable getCause(Throwable t) {
     	Throwable cause = null;

     	// Look for a specific cause for this kind of exception
     	if (t instanceof InvocationTargetException) {
     		cause = ((InvocationTargetException) t).getTargetException();
     	}

     	// If no specific cause, fall back to the general cause.
     	if (cause == null) {
     		cause = t.getCause();
     	}
     	return null;
     }

     /**
      * This method searches the causes of the specified throwable
      * until it finds one that is acceptable as a "root" cause.
      *
      * Example: If t is an AxisFault, the code traverses to the next cause.
      *
      * @param t Throwable
      * @return Throwable root cause
      */
     private static Throwable getRootCause(Throwable t) {
     	while (t != null) {
     		Throwable nextCause = null;
     		if (t instanceof InvocationTargetException ||
     		    t instanceof AxisFault) {
     			// Skip over this cause
     			nextCause = getCause(t);
     			if (nextCause == null) {
     				return t;
     			}
     			t = nextCause;
     		} else {
     			// This is the root cause
     			return t;
     		}
     	}
     	return t;
     }

 }
	/*
	* Copyright 2004,2005 The Apache Software Foundation.
	* Copyright 2006 International Business Machines Corp.
	*
	* Licensed 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;

	import java.lang.reflect.InvocationTargetException;

	import javax.xml.ws.ProtocolException;
	import javax.xml.ws.WebServiceException;
	import javax.xml.ws.http.HTTPException;
	import javax.xml.ws.soap.SOAPFaultException;

	import org.apache.axis2.AxisFault;
	import org.apache.axis2.jaxws.i18n.Messages;
	import org.apache.axis2.jaxws.message.MessageException;
	import org.apache.axis2.jaxws.message.MessageInternalException;
	import org.apache.commons.logging.Log;
	import org.apache.commons.logging.LogFactory;

	/**
	* ExceptionFactory is used to create exceptions within the JAX-WS implementation.
	* There are several reasons for using a factory to create exceptions.
	* 1. We can intercept all exception creation and add the appropriate logging/serviceability.
	* 2. Exceptions are chained. ExceptionFactory can lengthen or reduce the cause chains as
	* necessary to support the JAX-WS programming model.
	* 3. Prevents construction of the same exception. Uses similar principles as AxisFault.makeException.
	*
	* Example Usage:
	* // Example usage
	*
	* public fooMethod() throws WebServiceException {
	* try{
	* ...
	* }
	* catch(Exception e){
	* throw ExceptionFactory.makeWebServiceException(e);
	* }
	* }
	*
	*
	*/
	public class ExceptionFactory {

	protected static Log log =
	LogFactory.getLog(ExceptionFactory.class.getName());

	/**
	* Private Constructor
	* All methods are static. The private constructor prevents instantiation.
	*/
	private ExceptionFactory() {
	}

	/**
	* Create a WebServiceException using the information from a given Throwable instance
	* and message
	* @param message
	* @param throwable
	* @return WebServiceException
	*/
	public static WebServiceException makeWebServiceException(String message, Throwable throwable) {
	try {
	// See if there is already a WebServiceException (Note that the returned exception could be a ProtocolException or
	// other kind of exception)
	WebServiceException e = (WebServiceException) findException(throwable, WebServiceException.class);
	if (e == null) {
	e = createWebServiceException(message, throwable);
	}
	return e;
	} catch (RuntimeException re) {
	// TODO
	// This is not a good situation, an exception occurred while building the exception.
	// This should never occur! For now log the problem and rethrow...we may revisit this later
	if (log.isDebugEnabled()) {
	log.debug(Messages.getMessage("exceptionDuringExceptionFlow"), re);
	}
	throw re;
	}
	}

	/**
	* Create a ProtocolException using the information from a Throwable and message
	* @param message
	* @param throwable
	* @return ProtocolException
	*/
	public static ProtocolException makeProtocolException(String message, Throwable throwable) {
	try {
	// See if there is already a ProtocolException
	ProtocolException e = (ProtocolException) findException(throwable, ProtocolException.class);
	if (e == null) {
	e = createProtocolException(message, throwable);
	}
	return e;
	} catch (RuntimeException re) {
	// TODO
	// This is not a good situation, an exception occurred while building the exception.
	// This should never occur! For now log the problem and rethrow...we may revisit this later
	if (log.isDebugEnabled()) {
	log.debug(Messages.getMessage("exceptionDuringExceptionFlow"), re);
	}
	throw re;
	}
	}

	/**
	* Create a MessageException using the information from a Throwable and message
	* @param message
	* @param throwable
	* @return MessageException
	*/
	public static MessageException makeMessageException(String message, Throwable throwable) {
	try {
	// See if there is already a MessgeException
	MessageException e = (MessageException) findException(throwable, MessageException.class);
	if (e == null) {
	e = createMessageException(message, throwable);
	}
	return e;
	} catch (RuntimeException re) {
	// TODO
	// This is not a good situation, an exception occurred while building the exception.
	// This should never occur! For now log the problem and rethrow...we may revisit this later
	if (log.isDebugEnabled()) {
	log.debug(Messages.getMessage("exceptionDuringExceptionFlow"), re);
	}
	throw re;
	}
	}

	/**
	* Create a MessageInternalException using the information from a Throwable and message
	* @param message
	* @param throwable
	* @return MessageInternalException
	*/
	public static MessageInternalException makeMessageInternalException(String message, Throwable throwable) {
	try {
	// See if there is already a HTTPException
	MessageInternalException e = (MessageInternalException) findException(throwable, MessageInternalException.class);
	if (e == null) {
	e = createMessageInternalException(message, throwable);
	}
	return e;
	} catch (RuntimeException re) {
	// TODO
	// This is not a good situation, an exception occurred while building the exception.
	// This should never occur! For now log the problem and rethrow...we may revisit this later
	if (log.isDebugEnabled()) {
	log.debug(Messages.getMessage("exceptionDuringExceptionFlow"), re);
	}
	throw re;
	}
	}

	/**
	* Make a WebServiceException with a given message
	* @param message
	* @return WebServiceException
	*/
	public static WebServiceException makeWebServiceException(String message) {
	return makeWebServiceException(message, null);
	}

	/**
	* Create a WebServiceException using the information from a given Throwable instance
	* @param throwable
	* @return WebServiceException
	*/
	public static WebServiceException makeWebServiceException(Throwable throwable){
	return makeWebServiceException(null, throwable);
	}

	/**
	* Create a MessageException using the information from a given Throwable instance
	* @param throwable
	* @return MessageException
	*/
	public static MessageException makeMessageException(Throwable throwable){
	return makeMessageException(null, throwable);
	}

	/**
	* Make a MessageException with a given message
	* @param message
	* @return MessageException
	*/
	public static MessageException makeMessageException(String message) {
	return makeMessageException(message, null);
	}

	/**
	* Create a WebServiceException
	* @param message
	* @param t Throwable
	* @return WebServiceException
	*/
	private static WebServiceException createWebServiceException(String message, Throwable t) {
	Throwable rootCause = null;
	if (t != null) {
	rootCause = getRootCause(t);
	}
	WebServiceException e = new WebServiceException(message, t);
	if (log.isDebugEnabled()) {
	log.debug("Create Exception:", e);
	}
	return e;
	}

	/**
	* Create a ProtocolException
	* @param message
	* @param t Throwable
	* @return ProtocolException
	*/
	private static ProtocolException createProtocolException(String message, Throwable t) {
	Throwable rootCause = null;
	if (t != null) {
	rootCause = getRootCause(t);
	}
	ProtocolException e = new ProtocolException(message, t);
	if (log.isDebugEnabled()) {
	log.debug("create Exception:", t);
	}
	return e;
	}

	/**
	* Create a MessageException
	* @param message
	* @param t Throwable
	* @return MessageException
	*/
	private static MessageException createMessageException(String message, Throwable t) {
	Throwable rootCause = null;
	if (t != null) {
	rootCause = getRootCause(t);
	}
	MessageException e = new MessageException(message, t);
	if (log.isDebugEnabled()) {
	log.debug("create Exception:", t);
	}
	return e;
	}

	/**
	* Create a MessageInternalException
	* @param message
	* @param t Throwable
	* @return MessageException
	*/
	private static MessageInternalException createMessageInternalException(String message, Throwable t) {
	Throwable rootCause = null;
	if (t != null) {
	rootCause = getRootCause(t);
	}
	MessageInternalException e = new MessageInternalException(message, t);
	if (log.isDebugEnabled()) {
	log.debug("create Exception:", t);
	}
	return e;
	}

	/**
	* Return the exception or nested cause that is assignable from the specified class
	* @param t Throwable
	* @param cls
	* @return Exception or null
	*/
	private static Exception findException(Throwable t, Class cls) {
	while(t != null) {
	if (cls.isAssignableFrom(t.getClass())) {
	return (Exception) t;
	}
	t = getCause(t);
	}
	return null;
	}

	/**
	* Gets the Throwable cause of the Exception. Some exceptions
	* store the cause in a different field, which is why this method
	* should be used when walking the causes.
	* @param t Throwable
	* @return Throwable or null
	*/
	private static Throwable getCause(Throwable t) {
	Throwable cause = null;

	// Look for a specific cause for this kind of exception
	if (t instanceof InvocationTargetException) {
	cause = ((InvocationTargetException) t).getTargetException();
	}

	// If no specific cause, fall back to the general cause.
	if (cause == null) {
	cause = t.getCause();
	}
	return null;
	}

	/**
	* This method searches the causes of the specified throwable
	* until it finds one that is acceptable as a "root" cause.
	*
	* Example: If t is an AxisFault, the code traverses to the next cause.
	*
	* @param t Throwable
	* @return Throwable root cause
	*/
	private static Throwable getRootCause(Throwable t) {
	while (t != null) {
	Throwable nextCause = null;
	if (t instanceof InvocationTargetException \|\|
	t instanceof AxisFault) {
	// Skip over this cause
	nextCause = getCause(t);
	if (nextCause == null) {
	return t;
	}
	t = nextCause;
	} else {
	// This is the root cause
	return t;
	}
	}
	return t;
	}

	}