Java RetryException類代碼示例

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
@Override
public void execute(
		Foo foo, 
		String event, 
		Object ... args) throws RetryException {
	logger.debug("Hello {}", what);
	logger.debug("Received event={}, for Foo={}", event, foo);
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
@Override
public void execute(Standalone standalone, String event, Object... args) throws RetryException {
    standalone.getListeners().forEach(standaloneListener -> standaloneListener.beforeStop(standalone));
    standalone.stop();
    standalone.getListeners().forEach(standaloneListener -> standaloneListener.afterStop(standalone));
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
@Override
public void execute(Standalone standalone, String event, Object... args) throws RetryException {
    standalone.getListeners().forEach(standaloneListener -> standaloneListener.beforeResume(standalone));
    standalone.resume();
    standalone.getListeners().forEach(standaloneListener -> standaloneListener.afterResume(standalone));
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
@Override
public void execute(Standalone standalone, String event, Object... args) throws RetryException {
    standalone.getListeners().forEach(standaloneListener -> standaloneListener.beforeStart(standalone));
    standalone.start();
    standalone.getListeners().forEach(standaloneListener -> standaloneListener.afterStart(standalone));
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
@Override
public void execute(Standalone standalone, String event, Object... args) throws RetryException {
    standalone.getListeners().forEach(standaloneListener -> standaloneListener.beforeInitialize(standalone));
    standalone.initialize();
    standalone.getListeners().forEach(standaloneListener -> standaloneListener.afterInitialize(standalone));
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
@Override
public void execute(Standalone standalone, String event, Object... args) throws RetryException {
    standalone.getListeners().forEach(standaloneListener -> standaloneListener.beforeShutdown(standalone));
    standalone.shutdown();
    standalone.getListeners().forEach(standaloneListener -> standaloneListener.afterShutdown(standalone));
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
@Override
public void execute(Standalone standalone, String event, Object... args) throws RetryException {
    standalone.getListeners().forEach(standaloneListener -> standaloneListener.beforeSuspend(standalone));
    standalone.suspend();
    standalone.getListeners().forEach(standaloneListener -> standaloneListener.afterSuspend(standalone));
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
protected Object invoke(Object stateful, String event, List<Object> invokeParmList) throws RetryException, SecurityException, IllegalArgumentException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
	return invoke(this.controller, invokeParmList);
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
@Override
protected Object invoke(Object stateful, String event, List<Object> invokeParmList) throws RetryException, SecurityException, IllegalArgumentException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
	return invoke(stateful, invokeParmList);
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
@SuppressWarnings("unchecked")
@Test
public void testReload() throws RetryException {
	
	Identifiable value = new Identifiable(1L);

	Class<Identifiable> clazz = Identifiable.class;
	String event = "pow";
	Finder<Identifiable, Object> finder = mock(Finder.class);
	Object context = new Object();
	ContextWrapper<Object> cw = new ContextWrapper<Object>(context);
	
	when(finder.find(clazz, 1L, event, context)).thenReturn(value);
	
	State<Identifiable> from = mock(State.class);
	State<Identifiable> to = mock(State.class);
	Persister<Identifiable> persister = mock(Persister.class);
	ApplicationContext appContext = mock(ApplicationContext.class);
	when(appContext.getAutowireCapableBeanFactory()).thenReturn(mock(AutowireCapableBeanFactory.class));

	TransitionImpl<Identifiable> transition = new TransitionImpl<Identifiable>(
			from,
			to, 
			event,
			null,
			false,
			true);
	
	FSM<Identifiable, Object> fsm = new FSM<Identifiable, Object>(
			"fsm", 
			persister, 
			1, 
			1, 
			Identifiable.class, 
			Id.class, 
			appContext,
			finder);
	
	fsm.transition(value, from, event, transition, cw);
	verify(finder).find(clazz, 1L, event, context);
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
public void execute(T stateful, String event, Object ... args) throws RetryException{
	for(Action<T> action : this.actions) {
		action.execute(stateful, event, args);
	}
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
@Override
public void execute(T obj, String event, Object... args) throws RetryException {
	throw new WaitAndRetryException(this.wait);
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
public void execute(Order order, String event, Object... args) throws RetryException {
}
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
/**
 * Called to execute an action based off a State Transition.
 *
 * @param stateful The Stateful Entity
 * @param event The ocurring Event
 * @param args A set of optional arguments passed into the onEvent method of the {@link org.statefulj.fsm.FSM}
 * @throws RetryException thrown when the event must be retried due to Stale state or some other error condition
 */
void execute(T stateful, String event, Object ... args) throws RetryException;
 

import org.statefulj.fsm.RetryException; //導入依賴的package包/類
/**
 * Return the {@link org.statefulj.fsm.model.StateActionPair}
 *
 * @param stateful the Stateful Entity
 *
 * @return the {@link org.statefulj.fsm.model.StateActionPair}
 * @param event The occurring Event
 * @param args Optional parameters that was passed into the FSM
 *
 * @throws RetryException is thrown if there is an error determining the next State and Action and the FSM should
 *         re-process the event
 */
StateActionPair<T> getStateActionPair(T stateful, String event, Object ... args) throws RetryException;