import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
@PostDeploy
public void evaluateDecisionTable(ProcessEngine processEngine) {

  DecisionService decisionService = processEngine.getDecisionService();

  VariableMap variables = Variables.createVariables()
    .putValue("season", "Spring")
    .putValue("guestCount", 10)
    .putValue("guestsWithChildren", false);

  DmnDecisionTableResult dishDecisionResult = decisionService.evaluateDecisionTableByKey("dish", variables);
  String desiredDish = dishDecisionResult.getSingleEntry();

  System.out.println("Desired dish: " + desiredDish);

  DmnDecisionTableResult beveragesDecisionResult = decisionService.evaluateDecisionTableByKey("beverages", variables);
  List<Object> beverages = beveragesDecisionResult.collectEntries("beverages");

  System.out.println("Desired beverages: " + beverages);
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
@Override
public void notify(final DelegateTask delegateTask) {
  logger.info("Determining routing for {}", delegateTask.getTaskDefinitionKey());
  final DecisionService decisionService = delegateTask.getProcessEngineServices().getDecisionService();

  final Map<String, Object> vars = delegateTask.getVariables();
  final TaskHolder task = TaskHolder.fromTask(delegateTask);
  final CandidateResult candidateResult = skillBasedRoutingService(decisionService).evaluate(task, vars);

  if (candidateResult != null) {
    delegateTask.addCandidateUsers(candidateResult.getCandidateUsers());
  }
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
private boolean evaluateDecisionTable(double sum) {
  final DecisionService decisionService = processEngineRule.getDecisionService();
  final DmnDecisionTableResult results = decisionService.evaluateDecisionTableByKey("decision", Variables.createVariables().putValue("status", "silver").putValue("sum", 1500.0d));

  final String result = FluentIterable.from(results).first().get().getEntry("result");

  return "ok".equals(result);
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
@Test
public void shouldUseTheDmnTable(){
  DecisionService decisionService = processEngine.getDecisionService();
  VariableMap variableMap = Variables.createVariables().putValue("season", "Spring").putValue("guestCount", 10);
  DmnDecisionTableResult dishDecision = decisionService.evaluateDecisionTableByKey("dish", variableMap);
  String dish = dishDecision.getSingleEntry();

  assertThat(dish, is(equalTo("Stew")));
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
@Before
public void setUpRuntime() throws FileNotFoundException, URISyntaxException {
  DecisionRequirementsDefinition mockDecisionRequirementsDefinition = MockProvider.createMockDecisionRequirementsDefinition();

  setUpRuntimeData(mockDecisionRequirementsDefinition);
  decisionServiceMock = mock(DecisionService.class);
  when(processEngine.getDecisionService()).thenReturn(decisionServiceMock);
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
private void setUpDecisionService() {
  decisionEvaluationBuilderMock = mock(DecisionsEvaluationBuilder.class);
  when(decisionEvaluationBuilderMock.variables(anyMapOf(String.class, Object.class))).thenReturn(decisionEvaluationBuilderMock);

  decisionServiceMock = mock(DecisionService.class);
  when(decisionServiceMock.evaluateDecisionById(MockProvider.EXAMPLE_DECISION_DEFINITION_ID)).thenReturn(decisionEvaluationBuilderMock);
  when(decisionServiceMock.evaluateDecisionByKey(MockProvider.EXAMPLE_DECISION_DEFINITION_KEY)).thenReturn(decisionEvaluationBuilderMock);

  when(processEngine.getDecisionService()).thenReturn(decisionServiceMock);
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
public EvaluateDecisionTable(DecisionService decisionService) {
  this.decisionService = decisionService;
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
public DecisionService getDecisionService() {
  return processEngine.getDecisionService();
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
public SkillBasedRoutingService(DecisionService decisionService) {
  this.decisionService = decisionService;
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
@Override
public DecisionService getDecisionService() {
  return innerRule.getDecisionService();
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
@Override
public DecisionService getDecisionService() {
  return delegate.getDecisionService();
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
@Override
public DecisionService getDecisionService() {
  return outerRule.getDecisionService();
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
@Override
public DecisionService getDecisionService() {
  return processEngine.getDecisionService();
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
public DecisionService getDecisionService() {
  return decisionService;
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
public void setDecisionService(DecisionService decisionService) {
  this.decisionService = decisionService;
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
@Override
public DecisionService getDecisionService() {
  return decisionService;
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
@Override
public void execute(DelegateExecution execution) throws Exception {
  DecisionService decisionService = execution.getProcessEngineServices().getDecisionService();
  evaluateDecision(decisionService, execution);
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
public void notify(DelegateCaseExecution caseExecution) throws Exception {
  DecisionService decisionService = caseExecution.getProcessEngineServices().getDecisionService();
  evaluateDecision(decisionService, caseExecution);
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
public boolean evaluate(DelegateCaseExecution caseExecution) {
  DecisionService decisionService = caseExecution.getProcessEngineServices().getDecisionService();
  DmnDecisionTableResult result = evaluateDecision(decisionService, caseExecution);
  DmnDecisionRuleResult singleResult = result.getSingleResult();
  return (Boolean) singleResult.getSingleEntry();
}
 

import org.camunda.bpm.engine.DecisionService; //导入依赖的package包/类
protected DmnDecisionTableResult evaluateDecision(DecisionService decisionService, VariableScope variableScope) {
  return decisionService.evaluateDecisionTableByKey("testDecision", variableScope.getVariables());
}