/*
* Copyright 2005-2012 the original author or authors.
*
* 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.springframework.ws.server.endpoint;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.core.MethodParameter;
import org.springframework.util.Assert;
import org.springframework.util.ReflectionUtils;
/**
* Represents a bean method that will be invoked as part of an incoming Web service message.
*
* <p>Consists of a {@link Method}, and a bean {@link Object}.
*
* @author Arjen Poutsma
* @since 1.0.0
*/
public final class MethodEndpoint {
private final Object bean;
private final Method method;
private final BeanFactory beanFactory;
/**
* Constructs a new method endpoint with the given bean and method.
*
* @param bean the object bean
* @param method the method
*/
public MethodEndpoint(Object bean, Method method) {
Assert.notNull(bean, "bean must not be null");
Assert.notNull(method, "method must not be null");
this.bean = bean;
this.method = method;
this.beanFactory = null;
}
/**
* Constructs a new method endpoint with the given bean, method name and parameters.
*
* @param bean the object bean
* @param methodName the method name
* @param parameterTypes the method parameter types
* @throws NoSuchMethodException when the method cannot be found
*/
public MethodEndpoint(Object bean, String methodName, Class<?>... parameterTypes) throws NoSuchMethodException {
Assert.notNull(bean, "bean must not be null");
Assert.notNull(methodName, "method must not be null");
this.bean = bean;
this.method = bean.getClass().getMethod(methodName, parameterTypes);
this.beanFactory = null;
}
/**
* Constructs a new method endpoint with the given bean name and method. The bean name will be lazily initialized when
* {@link #invoke(Object...)} is called.
*
* @param beanName the bean name
* @param beanFactory the bean factory to use for bean initialization
* @param method the method
*/
public MethodEndpoint(String beanName, BeanFactory beanFactory, Method method) {
Assert.hasText(beanName, "'beanName' must not be null");
Assert.notNull(beanFactory, "'beanFactory' must not be null");
Assert.notNull(method, "'method' must not be null");
Assert.isTrue(beanFactory.containsBean(beanName),
"Bean factory [" + beanFactory + "] does not contain bean " + "with name [" + beanName + "]");
this.bean = beanName;
this.beanFactory = beanFactory;
this.method = method;
}
/** Returns the object bean for this method endpoint. */
public Object getBean() {
if (beanFactory != null && bean instanceof String) {
String beanName = (String) bean;
return beanFactory.getBean(beanName);
}
else {
return bean;
}
}
/** Returns the method for this method endpoint. */
public Method getMethod() {
return this.method;
}
/** Returns the method parameters for this method endpoint. */
public MethodParameter[] getMethodParameters() {
int parameterCount = getMethod().getParameterTypes().length;
MethodParameter[] parameters = new MethodParameter[parameterCount];
for (int i = 0; i < parameterCount; i++) {
parameters[i] = new MethodParameter(getMethod(), i);
}
return parameters;
}
/** Returns the method return type, as {@code MethodParameter}. */
public MethodParameter getReturnType() {
return new MethodParameter(method, -1);
}
/**
* Invokes this method endpoint with the given arguments.
*
* @param args the arguments
* @return the invocation result
* @throws Exception when the method invocation results in an exception
*/
public Object invoke(Object... args) throws Exception {
Object endpoint = getBean();
ReflectionUtils.makeAccessible(method);
try {
return method.invoke(endpoint, args);
}
catch (InvocationTargetException ex) {
handleInvocationTargetException(ex);
throw new IllegalStateException(
"Unexpected exception thrown by method - " + ex.getTargetException().getClass().getName() + ": " +
ex.getTargetException().getMessage());
}
}
private void handleInvocationTargetException(InvocationTargetException ex) throws Exception {
Throwable targetException = ex.getTargetException();
if (targetException instanceof RuntimeException) {
throw (RuntimeException) targetException;
}
if (targetException instanceof Error) {
throw (Error) targetException;
}
if (targetException instanceof Exception) {
throw (Exception) targetException;
}
}
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o != null && o instanceof MethodEndpoint) {
MethodEndpoint other = (MethodEndpoint) o;
return this.bean.equals(other.bean) && this.method.equals(other.method);
}
return false;
}
public int hashCode() {
return 31 * this.bean.hashCode() + this.method.hashCode();
}
public String toString() {
return method.toGenericString();
}
}