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.mina.statemachine.transition; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Arrays; import org.apache.commons.lang.builder.EqualsBuilder; import org.apache.commons.lang.builder.HashCodeBuilder; import org.apache.commons.lang.builder.ToStringBuilder; import org.apache.mina.statemachine.State; import org.apache.mina.statemachine.StateMachine; import org.apache.mina.statemachine.StateMachineFactory; import org.apache.mina.statemachine.annotation.Transition; import org.apache.mina.statemachine.context.StateContext; import org.apache.mina.statemachine.event.Event; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * {@link Transition} which invokes a {@link Method}. The {@link Method} will * only be invoked if its argument types actually matches a subset of the * {@link Event}'s argument types. The argument types are matched in order so * you must make sure the order of the method's arguments corresponds to the * order of the event's arguments. *<p> * If the first method argument type matches * {@link Event} the current {@link Event} will be bound to that argument. In * the same manner the second argument (or first if the method isn't interested * in the current {@link Event}) can have the {@link StateContext} type and will * in that case be bound to the current {@link StateContext}. * </p> * <p> * Normally you wouldn't create instances of this class directly but rather use the * {@link Transition} annotation to define the methods which should be used as * transitions in your state machine and then let {@link StateMachineFactory} create a * {@link StateMachine} for you. * </p> * * @author The Apache MINA Project (dev@mina.apache.org) * @version $Rev: 592122 $, $Date: 2007-11-05 20:10:32 +0100 (lun, 05 nov 2007) $ */ public class MethodTransition extends AbstractTransition { private static final Logger log = LoggerFactory.getLogger(MethodTransition.class); private static final Object[] EMPTY_ARGUMENTS = new Object[0]; private final Method method; private final Object target; /** * Creates a new instance with the specified {@link State} as next state * and for the specified {@link Event} id. * * @param eventId the {@link Event} id. * @param nextState the next {@link State}. * @param method the target method. * @param target the target object. */ public MethodTransition(Object eventId, State nextState, Method method, Object target) { super(eventId, nextState); this.method = method; this.target = target; } /** * Creates a new instance which will loopback to the same {@link State} * for the specified {@link Event} id. * * @param eventId the {@link Event} id. * @param method the target method. * @param target the target object. */ public MethodTransition(Object eventId, Method method, Object target) { this(eventId, null, method, target); } /** * Creates a new instance with the specified {@link State} as next state * and for the specified {@link Event} id. The target {@link Method} will * be the method in the specified target object with the same name as the * specified {@link Event} id. * * @param eventId the {@link Event} id. * @param nextState the next {@link State}. * @param target the target object. * @throws NoSuchMethodException if no method could be found with a name * equal to the {@link Event} id. * @throws AmbiguousMethodException if more than one method was found with * a name equal to the {@link Event} id. */ public MethodTransition(Object eventId, State nextState, Object target) { this(eventId, nextState, eventId.toString(), target); } /** * Creates a new instance which will loopback to the same {@link State} * for the specified {@link Event} id. The target {@link Method} will * be the method in the specified target object with the same name as the * specified {@link Event} id. * * @param eventId the {@link Event} id. * @param target the target object. * @throws NoSuchMethodException if no method could be found with a name * equal to the {@link Event} id. * @throws AmbiguousMethodException if more than one method was found with * a name equal to the {@link Event} id. */ public MethodTransition(Object eventId, Object target) { this(eventId, eventId.toString(), target); } /** * Creates a new instance which will loopback to the same {@link State} * for the specified {@link Event} id. * * @param eventId the {@link Event} id. * @param methodName the name of the target {@link Method}. * @param target the target object. * @throws NoSuchMethodException if the method could not be found. * @throws AmbiguousMethodException if there are more than one method with * the specified name. */ public MethodTransition(Object eventId, String methodName, Object target) { this(eventId, null, methodName, target); } /** * Creates a new instance with the specified {@link State} as next state * and for the specified {@link Event} id. * * @param eventId the {@link Event} id. * @param nextState the next {@link State}. * @param methodName the name of the target {@link Method}. * @param target the target object. * @throws NoSuchMethodException if the method could not be found. * @throws AmbiguousMethodException if there are more than one method with * the specified name. */ public MethodTransition(Object eventId, State nextState, String methodName, Object target) { super(eventId, nextState); this.target = target; Method[] candidates = target.getClass().getMethods(); Method result = null; for (int i = 0; i < candidates.length; i++) { if (candidates[i].getName().equals(methodName)) { if (result != null) { throw new AmbiguousMethodException(methodName); } result = candidates[i]; } } if (result == null) { throw new NoSuchMethodException(methodName); } this.method = result; } /** * Returns the target {@link Method}. * * @return the method. */ public Method getMethod() { return method; } /** * Returns the target object. * * @return the target object. */ public Object getTarget() { return target; } public boolean doExecute(Event event) { Class<?>[] types = method.getParameterTypes(); if (types.length == 0) { invokeMethod(EMPTY_ARGUMENTS); return true; } if (types.length > 2 + event.getArguments().length) { return false; } Object[] args = new Object[types.length]; int i = 0; if (match(types[i], event, Event.class)) { args[i++] = event; } if (i < args.length && match(types[i], event.getContext(), StateContext.class)) { args[i++] = event.getContext(); } Object[] eventArgs = event.getArguments(); for (int j = 0; i < args.length && j < eventArgs.length; j++) { if (match(types[i], eventArgs[j], Object.class)) { args[i++] = eventArgs[j]; } } if (args.length > i) { return false; } invokeMethod(args); return true; } @SuppressWarnings("unchecked") private boolean match(Class<?> paramType, Object arg, Class argType) { if (paramType.isPrimitive()) { if (paramType.equals(Boolean.TYPE)) { return arg instanceof Boolean; } if (paramType.equals(Integer.TYPE)) { return arg instanceof Integer; } if (paramType.equals(Long.TYPE)) { return arg instanceof Long; } if (paramType.equals(Short.TYPE)) { return arg instanceof Short; } if (paramType.equals(Byte.TYPE)) { return arg instanceof Byte; } if (paramType.equals(Double.TYPE)) { return arg instanceof Double; } if (paramType.equals(Float.TYPE)) { return arg instanceof Float; } if (paramType.equals(Character.TYPE)) { return arg instanceof Character; } } return argType.isAssignableFrom(paramType) && paramType.isAssignableFrom(arg.getClass()); } private void invokeMethod(Object[] arguments) { try { if (log.isDebugEnabled()) { log.debug("Executing method " + method + " with arguments " + Arrays.asList(arguments)); } method.invoke(target, arguments); } catch (InvocationTargetException ite) { if (ite.getCause() instanceof RuntimeException) { throw (RuntimeException) ite.getCause(); } throw new MethodInvocationException(method, ite); } catch (IllegalAccessException iae) { throw new MethodInvocationException(method, iae); } } public boolean equals(Object o) { if (!(o instanceof MethodTransition)) { return false; } if (o == this) { return true; } MethodTransition that = (MethodTransition) o; return new EqualsBuilder().appendSuper(super.equals(that)).append(method, that.method) .append(target, that.target).isEquals(); } public int hashCode() { return new HashCodeBuilder(13, 33).appendSuper(super.hashCode()).append(method).append(target).toHashCode(); } public String toString() { return new ToStringBuilder(this).appendSuper(super.toString()).append("method", method) .append("target", target).toString(); } }