public class CustomSmartEndpointInterceptor extends Wss4jSecurityInterceptor implements SmartEndpointInterceptor { //CustomEndpoint is your @Endpoint class @Override public boolean shouldIntercept(MessageContext messageContext, Object endpoint) { if (endpoint instanceof MethodEndpoint) { MethodEndpoint methodEndpoint = (MethodEndpoint)endpoint; return methodEndpoint.getMethod().getDeclaringClass() == CustomEndpoint.class; } return false; } }
/** * 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()); } }
@Override protected final void invokeInternal(MessageContext messageContext, MethodEndpoint methodEndpoint) throws Exception { Object[] args = getMethodArguments(messageContext, methodEndpoint); if (logger.isTraceEnabled()) { logger.trace("Invoking [" + methodEndpoint + "] with arguments " + Arrays.asList(args)); } Object returnValue = methodEndpoint.invoke(args); if (logger.isTraceEnabled()) { logger.trace("Method [" + methodEndpoint + "] returned [" + returnValue + "]"); } Class<?> returnType = methodEndpoint.getMethod().getReturnType(); if (!Void.TYPE.equals(returnType)) { handleMethodReturnValue(messageContext, returnValue, methodEndpoint); } }
@Override protected boolean supportsInternal(MethodEndpoint methodEndpoint) { return supportsParameters(methodEndpoint.getMethodParameters()) && supportsReturnType(methodEndpoint.getReturnType()); }
@Override protected void invokeInternal(MessageContext messageContext, MethodEndpoint methodEndpoint) throws Exception { methodEndpoint.invoke(messageContext); }
public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException { List<T> keys = getLookupKeysForMethod(method); for (T key : keys) { registerEndpoint(key, new MethodEndpoint(endpoint, method)); } } });
/** * Default implementation that checks whether the given <code>endpoint</code> is in the set of {@link * #setMappedEndpoints mapped endpoints}. * * @see #resolveExceptionInternal(MessageContext,Object,Exception) */ public final boolean resolveException(MessageContext messageContext, Object endpoint, Exception ex) { Object mappedEndpoint = endpoint instanceof MethodEndpoint ? ((MethodEndpoint) endpoint).getBean() : endpoint; if (mappedEndpoints != null && !mappedEndpoints.contains(mappedEndpoint)) { return false; } // Log exception, both at debug log level and at warn level, if desired. if (logger.isDebugEnabled()) { logger.debug("Resolving exception from endpoint [" + endpoint + "]: " + ex); } logException(ex, messageContext); return resolveExceptionInternal(messageContext, endpoint, ex); }
/** * Returns the argument array for the given method endpoint. * * <p>This implementation iterates over the set {@linkplain #setMethodArgumentResolvers(List) argument resolvers} to * resolve each argument. * * @param messageContext the current message context * @param methodEndpoint the method endpoint to get arguments for * @return the arguments * @throws Exception in case of errors */ protected Object[] getMethodArguments(MessageContext messageContext, MethodEndpoint methodEndpoint) throws Exception { MethodParameter[] parameters = methodEndpoint.getMethodParameters(); Object[] args = new Object[parameters.length]; for (int i = 0; i < parameters.length; i++) { for (MethodArgumentResolver methodArgumentResolver : methodArgumentResolvers) { if (methodArgumentResolver.supportsParameter(parameters[i])) { args[i] = methodArgumentResolver.resolveArgument(messageContext, parameters[i]); break; } } } return args; }
/** * Handle the return value for the given method endpoint. * * <p>This implementation iterates over the set {@linkplain #setMethodReturnValueHandlers(java.util.List)} return value * handlers} to resolve the return value. * * @param messageContext the current message context * @param returnValue the return value * @param methodEndpoint the method endpoint to get arguments for * @throws Exception in case of errors */ protected void handleMethodReturnValue(MessageContext messageContext, Object returnValue, MethodEndpoint methodEndpoint) throws Exception { MethodParameter returnType = methodEndpoint.getReturnType(); for (MethodReturnValueHandler methodReturnValueHandler : methodReturnValueHandlers) { if (methodReturnValueHandler.supportsReturnType(returnType)) { methodReturnValueHandler.handleReturnValue(messageContext, returnType, returnValue); return; } } throw new IllegalStateException( "Return value [" + returnValue + "] not resolved by any MethodReturnValueHandler"); } }
/** * 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 = bean; if (endpoint instanceof String) { String endpointName = (String) endpoint; endpoint = beanFactory.getBean(endpointName); } 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()); } }
@Override protected void invokeInternal(MessageContext messageContext, MethodEndpoint methodEndpoint) throws Exception { methodEndpoint.invoke(messageContext); }
@Override protected boolean supportsInternal(MethodEndpoint methodEndpoint) { return supportsParameters(methodEndpoint.getMethodParameters()) && supportsReturnType(methodEndpoint.getReturnType()); }
public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException { T key = getLookupKeyForMethod(method); if (key != null) { registerEndpoint(key, new MethodEndpoint(endpoint, method)); } } });
/** * Default implementation that checks whether the given {@code endpoint} is in the set of {@link * #setMappedEndpoints mapped endpoints}. * * @see #resolveExceptionInternal(MessageContext,Object,Exception) */ @Override public final boolean resolveException(MessageContext messageContext, Object endpoint, Exception ex) { Object mappedEndpoint = endpoint instanceof MethodEndpoint ? ((MethodEndpoint) endpoint).getBean() : endpoint; if (mappedEndpoints != null && !mappedEndpoints.contains(mappedEndpoint)) { return false; } // Log exception, both at debug log level and at warn level, if desired. if (logger.isDebugEnabled()) { logger.debug("Resolving exception from endpoint [" + endpoint + "]: " + ex); } logException(ex, messageContext); return resolveExceptionInternal(messageContext, endpoint, ex); }
/** * Returns the argument array for the given method endpoint. * * <p>This implementation iterates over the set {@linkplain #setMethodArgumentResolvers(List) argument resolvers} to * resolve each argument. * * @param messageContext the current message context * @param methodEndpoint the method endpoint to get arguments for * @return the arguments * @throws Exception in case of errors */ protected Object[] getMethodArguments(MessageContext messageContext, MethodEndpoint methodEndpoint) throws Exception { MethodParameter[] parameters = methodEndpoint.getMethodParameters(); Object[] args = new Object[parameters.length]; for (int i = 0; i < parameters.length; i++) { for (MethodArgumentResolver methodArgumentResolver : methodArgumentResolvers) { if (methodArgumentResolver.supportsParameter(parameters[i])) { args[i] = methodArgumentResolver.resolveArgument(messageContext, parameters[i]); break; } } } return args; }
/** * Handle the return value for the given method endpoint. * <p/> * This implementation iterates over the set {@linkplain #setMethodReturnValueHandlers(java.util.List)} return value * handlers} to resolve the return value. * * @param messageContext the current message context * @param returnValue the return value * @param methodEndpoint the method endpoint to get arguments for * @throws Exception in case of errors */ protected void handleMethodReturnValue(MessageContext messageContext, Object returnValue, MethodEndpoint methodEndpoint) throws Exception { MethodParameter returnType = methodEndpoint.getReturnType(); for (MethodReturnValueHandler methodReturnValueHandler : methodReturnValueHandlers) { if (methodReturnValueHandler.supportsReturnType(returnType)) { methodReturnValueHandler.handleReturnValue(messageContext, returnType, returnValue); return; } } throw new IllegalStateException( "Return value [" + returnValue + "] not resolved by any MethodReturnValueHandler"); } }
/** 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; }
@Override protected final void invokeInternal(MessageContext messageContext, MethodEndpoint methodEndpoint) throws Exception { Object[] args = getMethodArguments(messageContext, methodEndpoint); if (logger.isTraceEnabled()) { logger.trace("Invoking [" + methodEndpoint + "] with arguments " + Arrays.asList(args)); } Object returnValue = methodEndpoint.invoke(args); if (logger.isTraceEnabled()) { logger.trace("Method [" + methodEndpoint + "] returned [" + returnValue + "]"); } Class<?> returnType = methodEndpoint.getMethod().getReturnType(); if (!Void.TYPE.equals(returnType)) { handleMethodReturnValue(messageContext, returnValue, methodEndpoint); } }
@Override protected void invokeInternal(MessageContext messageContext, MethodEndpoint methodEndpoint) throws Exception { methodEndpoint.invoke(messageContext); }
/** * 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()); } }