Java JavaDelegate类代码示例

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
public void notify(DelegateExecution execution) throws Exception {
  // Note: we can't cache the result of the expression, because the
  // execution can change: eg. delegateExpression='${mySpringBeanFactory.randomSpringBean()}'
  Object delegate = expression.getValue(execution);
  
  if (delegate instanceof ExecutionListener) {
    Context.getProcessEngineConfiguration()
      .getDelegateInterceptor()
      .handleInvocation(new ExecutionListenerInvocation((ExecutionListener) delegate, execution));
  } else if (delegate instanceof JavaDelegate) {
    Context.getProcessEngineConfiguration()
      .getDelegateInterceptor()
      .handleInvocation(new JavaDelegateInvocation((JavaDelegate) delegate, execution));
  } else {
    throw new ActivitiException("Delegate expression " + expression 
            + " did not resolve to an implementation of " + ExecutionListener.class 
            + " nor " + JavaDelegate.class);
  }
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
public void execute(ActivityExecution execution) throws Exception {
  
  // Note: we can't cache the result of the expression, because the
  // execution can change: eg. delegateExpression='${mySpringBeanFactory.randomSpringBean()}'
  Object delegate = expression.getValue(execution);
  
  if (delegate instanceof ActivityBehavior) {
    Context.getProcessEngineConfiguration()
      .getDelegateInterceptor()
      .handleInvocation(new ActivityBehaviorInvocation((ActivityBehavior) delegate, execution));

  } else if (delegate instanceof JavaDelegate) {
    Context.getProcessEngineConfiguration()
      .getDelegateInterceptor()
      .handleInvocation(new JavaDelegateInvocation((JavaDelegate) delegate, execution));
    leave(execution);
  
  } else {
    throw new ActivitiException("Delegate expression " + expression 
            + " did not resolve to an implementation of " + ActivityBehavior.class 
            + " nor " + JavaDelegate.class);
  }
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
protected ActivityBehavior getActivityBehaviorInstance(ActivityExecution execution) {
  Object delegateInstance = instantiateDelegate(className, fieldDeclarations);
  
  if (delegateInstance instanceof ActivityBehavior) {
    return determineBehaviour((ActivityBehavior) delegateInstance, execution);
  } else if (delegateInstance instanceof JavaDelegate) {
    return determineBehaviour(new ServiceTaskJavaDelegateActivityBehavior((JavaDelegate) delegateInstance), execution);
  } else {
    throw new ActivitiException(delegateInstance.getClass().getName()+" doesn't implement "+JavaDelegate.class.getName()+" nor "+ActivityBehavior.class.getName());
  }
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
@Test
public void testWithAListOfEndedProcesses() throws Exception {
    DelegateExecution execution = mock(DelegateExecution.class);
    when(execution.getVariable(eq(PROCESS_IDS))).thenReturn(Lists.newArrayList("1", "2"));

    ProcessVariablesCollector collector = new ProcessVariablesCollector();
    collector.install(execution);

    RuntimeService runtimeService = mockRuntimeService(ImmutableMap.of(
        "1", mockProcessInstance(/* ended= */ true),
        "2", mockProcessInstance(/* ended= */ true)
    ));

    JavaDelegate delegate = new CheckProcessesEnded(runtimeService, PROCESS_IDS, RESULT);
    delegate.execute(execution);

    assertThat((Boolean) collector.getVariable(RESULT)).isTrue();
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
@Test
public void testWithOneEndedAndOneStillRunning() throws Exception {
    DelegateExecution execution = mock(DelegateExecution.class);
    when(execution.getVariable(eq(PROCESS_IDS))).thenReturn(Lists.newArrayList("1", "2"));

    ProcessVariablesCollector collector = new ProcessVariablesCollector();
    collector.install(execution);

    RuntimeService runtimeService = mockRuntimeService(ImmutableMap.of(
        "1", mockProcessInstance(/* ended= */ true),
        "2", mockProcessInstance(/* ended= */ false)
    ));

    JavaDelegate delegate = new CheckProcessesEnded(runtimeService, PROCESS_IDS, RESULT);
    delegate.execute(execution);

    assertThat((Boolean) collector.getVariable(RESULT)).isFalse();
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
/**
 * We consider an invalid process instance ID as ended by default
 */
@Test
public void testWithOneInvalidProcessId() throws Exception {
    DelegateExecution execution = mock(DelegateExecution.class);
    when(execution.getVariable(eq(PROCESS_IDS))).thenReturn(Lists.newArrayList("1", "invalid"));

    ProcessVariablesCollector collector = new ProcessVariablesCollector();
    collector.install(execution);

    RuntimeService runtimeService = mockRuntimeService(ImmutableMap.of(
        "1", mockProcessInstance(/* ended= */ true)), "invalid");

    JavaDelegate delegate = new CheckProcessesEnded(runtimeService, PROCESS_IDS, RESULT);
    delegate.execute(execution);

    assertThat((Boolean) collector.getVariable(RESULT)).isTrue();
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
@Test
public void testWithRandomOpenPort() throws Exception {
    DelegateExecution execution = mock(DelegateExecution.class);

    when(execution.getVariable(eq(IsMachinePortOpen.MACHINE)))
        .thenReturn(Machine.builder().localhost().createMachine());

    ProcessVariablesCollector collector = new ProcessVariablesCollector();
    collector.install(execution);

    ServerSocket socket = null;
    try {
        socket = new ServerSocket(0);

        JavaDelegate delegate = new IsMachinePortOpen(RESULT, socket.getLocalPort());
        delegate.execute(execution);

        assertThat((Boolean) collector.getVariable(RESULT)).isTrue();

    } finally {
        if (socket != null) {
            socket.close();
        }
    }
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
protected ActivityBehavior getActivityBehaviorInstance(ActivityExecution execution) {
  Object delegateInstance = instantiateDelegate(className, fieldDeclarations);
  
  if (delegateInstance instanceof ActivityBehavior) {
    return determineBehaviour((ActivityBehavior) delegateInstance, execution);
  } else if (delegateInstance instanceof JavaDelegate) {
    return determineBehaviour(new ServiceTaskJavaDelegateActivityBehavior((JavaDelegate) delegateInstance), execution);
  } else {
    throw new ActivitiIllegalArgumentException(delegateInstance.getClass().getName()+" doesn't implement "+JavaDelegate.class.getName()+" nor "+ActivityBehavior.class.getName());
  }
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
public void notify(DelegateExecution execution) throws Exception {
  // Note: we can't cache the result of the expression, because the
  // execution can change: eg. delegateExpression='${mySpringBeanFactory.randomSpringBean()}'
  Object delegate = expression.getValue(execution);
  ClassDelegate.applyFieldDeclaration(fieldDeclarations, delegate);
  
  if (delegate instanceof ExecutionListener) {
    Context.getProcessEngineConfiguration()
      .getDelegateInterceptor()
      .handleInvocation(new ExecutionListenerInvocation((ExecutionListener) delegate, execution));
  } else if (delegate instanceof JavaDelegate) {
    Context.getProcessEngineConfiguration()
      .getDelegateInterceptor()
      .handleInvocation(new JavaDelegateInvocation((JavaDelegate) delegate, execution));
  } else {
    throw new ActivitiIllegalArgumentException("Delegate expression " + expression 
            + " did not resolve to an implementation of " + ExecutionListener.class 
            + " nor " + JavaDelegate.class);
  }
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
protected ExecutionListener getExecutionListenerInstance() {
  Object delegateInstance = instantiateDelegate(className, fieldDeclarations);
  if (delegateInstance instanceof ExecutionListener) {
    return (ExecutionListener) delegateInstance; 
  } else if (delegateInstance instanceof JavaDelegate) {
    return new ServiceTaskJavaDelegateActivityBehavior((JavaDelegate) delegateInstance);
  } else {
    throw new ActivitiException(delegateInstance.getClass().getName()+" doesn't implement "+ExecutionListener.class+" nor "+JavaDelegate.class);
  }
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
public void unbindService(JavaDelegate delegate, Map props) {
	String name = (String) props.get("osgi.service.blueprint.compname");
   if(delegateMap.containsKey(name)) {
   	delegateMap.remove(name);
   }
   LOGGER.info("removed Activiti service from delegate cache " + name);
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
protected JavaDelegate javaDelegateFromExistingBean(final Object o) throws BeansException {
    // first create a proxy that implements JavaDelegate
    // then setup logic to dispatch to a cached metadata map containing the methods on the class as well as
    // the particular runtime arguments those methods require, including access to things like @ProcessVariable annotations

    if (o instanceof JavaDelegate) {
        return (JavaDelegate) o;
    }

    final Method javaDelegateExecutionMethod =
            MethodUtils.getAccessibleMethod(JavaDelegate.class, "execute", DelegateExecution.class);

    ProxyFactory proxyFactory = new ProxyFactory(o);
    proxyFactory.setProxyTargetClass(true);
    proxyFactory.addInterface(JavaDelegate.class);
    proxyFactory.addAdvice(new MethodInterceptor() {
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
            // if its one type of method handle it our selves
            // by looking up the appropriate handler method and invoking it dynamically

            Method method = invocation.getMethod();

            // either its a request we can handle
            if (method.equals(javaDelegateExecutionMethod)) {
                DelegateExecution delegateExecution = (DelegateExecution) invocation.getArguments()[0];
                delegateTo(o, delegateExecution);
                return null;
            }

            // otherwise pass thru
            return invocation.proceed();
        }
    });
    return (JavaDelegate) proxyFactory.getProxy();
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
@Test
public void testSpawnSampleProcessForLocalhost() throws Exception {
    DelegateExecution execution = mock(DelegateExecution.class);
    Pool pool = mock(Pool.class, withSettings().serializable());
    Software software = mock(Software.class, withSettings().serializable());
    when(software.isCachedImage()).thenReturn(false);
    when(pool.getSoftware()).thenReturn(software);
    when(execution.getVariable(eq(CoreProcessVariables.POOL))).thenReturn(pool);
    when(execution.getVariable(eq(CoreProcessVariables.POOL_BUSINESS_KEY))).thenReturn(BUSINESS_KEY);

    List<Machine> machines = Lists.newArrayList(
        Machine.builder().localhost().createMachine(),
        Machine.builder().localhost().externalId("local-2").createMachine()
    );
    when(execution.getVariable(eq(CoreProcessVariables.MACHINES))).thenReturn(machines);

    ProcessVariablesCollector collector = new ProcessVariablesCollector();
    collector.install(execution);

    ProcessEngine processEngine = new StandaloneInMemProcessEngineConfiguration()
        .setJobExecutorActivate(true).buildProcessEngine();
    processEngine.getRepositoryService().createDeployment()
        .addClasspathResource("diagrams/empty.bpmn20.xml").deploy();

    try {
        JavaDelegate delegate = new SpawnProcessForEachMachine(processEngine, EMPTY_PROCESS_KEY, "test", RESULT);
        delegate.execute(execution);

        @SuppressWarnings("unchecked")
        List<String> processInstanceIds = (List<String>) collector.getVariable(RESULT);

        assertThat(processInstanceIds).hasSize(2);

    } finally {
        processEngine.close();
    }
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
@Test
public void testWithRandomClosedPort() throws Exception {
    DelegateExecution execution = mock(DelegateExecution.class);

    when(execution.getVariable(eq(IsMachinePortOpen.MACHINE)))
        .thenReturn(Machine.builder().localhost().createMachine());

    ProcessVariablesCollector collector = new ProcessVariablesCollector();
    collector.install(execution);

    JavaDelegate delegate = new IsMachinePortOpen(RESULT, findRandomNotUsedPort());
    delegate.execute(execution);

    assertThat((Boolean) collector.getVariable(RESULT)).isFalse();
}
 

import org.activiti.engine.delegate.JavaDelegate; //导入依赖的package包/类
private RuntimeService runTest(List<String> processIds, Map<String, ProcessInstance> processMap) throws Exception {
    DelegateExecution execution = mock(DelegateExecution.class);
    when(execution.getVariable(eq(PROCESS_IDS))).thenReturn(processIds);

    ProcessVariablesCollector collector = new ProcessVariablesCollector();
    collector.install(execution);

    RuntimeService runtimeService = mockRuntimeService(processMap, "invalid");

    JavaDelegate delegate = new KillMachineSetUpProcesses(runtimeService, PROCESS_IDS);
    delegate.execute(execution);

    return runtimeService;
}