Java SupervisorStrategy.stop方法代码示例

import akka.actor.SupervisorStrategy; //导入方法依赖的package包/类
@Override
public SupervisorStrategy supervisorStrategy() {
    return new OneForOneStrategy(10, Duration.create(1, TimeUnit.MINUTES),
            new Function<Throwable, SupervisorStrategy.Directive>() {
                @Override
                public SupervisorStrategy.Directive apply(Throwable param)
                         throws Exception {
                    if (param instanceof
                            IllegalArgumentException)
                        return SupervisorStrategy.restart();
                    if (param instanceof
                            ArithmeticException)
                        return SupervisorStrategy.resume();
                    if (param instanceof
                            NullPointerException)
                        return SupervisorStrategy.stop();
                    else return SupervisorStrategy.escalate();
                }
            }
    );
}
 

import akka.actor.SupervisorStrategy; //导入方法依赖的package包/类
@Override
public Directive apply(Throwable t) {
  logger.error(t, "Unknown failure");
  if (t instanceof RuntimeException) {
    return SupervisorStrategy.restart();
  } else {
    return SupervisorStrategy.stop();
  }
}
 

import akka.actor.SupervisorStrategy; //导入方法依赖的package包/类
@Override
public SupervisorStrategy supervisorStrategy() {
    return new AllForOneStrategy(10, Duration.create(1, TimeUnit.HOURS),
            new Function<Throwable, SupervisorStrategy.Directive>() {
                @Override
                public SupervisorStrategy.Directive apply(Throwable param) throws Exception {
                    if (param instanceof IllegalArgumentException) return SupervisorStrategy.stop();
                    if (param instanceof ArithmeticException) return SupervisorStrategy.resume();
                    if (param instanceof NullPointerException) return SupervisorStrategy.restart();
                    else return SupervisorStrategy.escalate();
                }
            }
    );
}
 

import akka.actor.SupervisorStrategy; //导入方法依赖的package包/类
/**
 * Returns how to handle the given fault that occurred in a child actor.
 *
 * <p>If an exception occurs in the child actor, we send a {@link Status.Failure} message to this actor.
 * Otherwise, if the {@link Throwable} is not an exception, the failure is escalated; that is, this actor will
 * fail itself.
 *
 * <p>The strategy deactivates the Akka-provided logging, which logs all exception as errors by default. Instead,
 * this strategy performs its own logging: If the {@link Throwable} is an {@link Exception}, the exception is logged
 * at the debug level. Otherwise, the {@link Throwable} is logged at the error level.
 */
private SupervisorStrategy.Directive supervisorDirective(Throwable throwable) {
    if (throwable instanceof Exception) {
        InterpreterException exception = throwable instanceof InterpreterException
            ? (InterpreterException) throwable
            : new InterpreterException(
                ExecutionTrace.empty(),
                String.format("Failure of root-module interpreter %s.", getSender()),
                throwable
            );

        if (log.isDebugEnabled()) {
            StringWriter stringWriter = new StringWriter();
            PrintWriter writer = new PrintWriter(stringWriter);
            writer.println(
                "Exception thrown in root-module interpreter and caught in top-level interpreter.");
            throwable.printStackTrace(writer);
            log.debug(stringWriter.toString());
        }

        getSelf().tell(new Status.Failure(exception), getSender());
        return SupervisorStrategy.stop();
    } else {
        log.error(throwable, "Error in root-module interpreter. Escalating... The JVM may not survive.");
        return SupervisorStrategy.escalate();
    }
}
 

import akka.actor.SupervisorStrategy; //导入方法依赖的package包/类
@Override
public SupervisorStrategy.Directive apply(Throwable throwable) {
    if (throwable instanceof Exception) {
        return SupervisorStrategy.stop();
    } else {
        return SupervisorStrategy.escalate();
    }
}
 

import akka.actor.SupervisorStrategy; //导入方法依赖的package包/类
/**
 * Returns how to handle the given fault that occurred in a child actor.
 */
private SupervisorStrategy.Directive supervisorDirective(Throwable throwable) {
    if (throwable instanceof InterpreterException) {
        return SupervisorStrategy.escalate();
    } else if (throwable instanceof Exception) {
        InterpreterException interpreterException = mapChildException((Exception) throwable);
        getSelf().tell(new ChildActorFailed(interpreterException), getSelf());
        return SupervisorStrategy.stop();
    } else {
        return SupervisorStrategy.escalate();
    }
}
 

import akka.actor.SupervisorStrategy; //导入方法依赖的package包/类
private SupervisorStrategy.Directive supervisorDirective(Throwable throwable) {
    // We cannot just re-throw the exception here because it would be caught by the actor system (which would
    // just restart the actor). We therefore schedule a deferred exception directly in the
    // CallingThreadExecutor.
    asyncTaskExecutor.execute(() -> { throw new UncaughtThrowableException(throwable); });
    return SupervisorStrategy.stop();
}
 

import akka.actor.SupervisorStrategy; //导入方法依赖的package包/类
@Override
public Directive apply(Throwable t) {
 if (t instanceof ArithmeticException) {
 	return SupervisorStrategy.resume() ; 
 } else if (t instanceof NullPointerException) {
 	return SupervisorStrategy.stop();
 } else if (t instanceof IllegalArgumentException) {
 	return SupervisorStrategy.stop();
 } else {
 	return SupervisorStrategy.escalate();
 }
}
 

import akka.actor.SupervisorStrategy; //导入方法依赖的package包/类
private Function<Throwable, Directive> myDecider()
{
	return new Function<Throwable, Directive>()
	{
		@Override
		public Directive apply(Throwable t)
		{
			if ( t instanceof ActorInitializationException
				 || t instanceof ActorKilledException
				 || t instanceof DeathPactException ) 
			{
				return SupervisorStrategy.stop();
			} 
			else if ( t instanceof Exception ) 
			{
				Class<? extends Throwable> clazz = t.getClass();
				ImmutableSet<Entry<Class<?>, Method>> entrySet = javactorInfoByJavactorType
					.get(javactor.getClass()).getSupervisorStrategyInfo().getOnExceptionMethods()
					.entrySet();
				for (Entry<Class<?>, Method> entry : entrySet)
				{
					if (entry.getKey().isAssignableFrom(clazz))
					{
						final Method method = entry.getValue();
						try
						{
							return map((SupervisorDirective) methodInvoke(
								method, javactor, t));
						} catch (Exception e)
						{
							throw new RuntimeException(e);
						}
					}
				}
				return SupervisorStrategy.restart();
			} else {
				return SupervisorStrategy.escalate();
			}
		}
	};
}