executionreadserviceimpl.java

一个java工作流引擎

package org.jbpm.service;

import java.util.*;
import org.jbpm.*;
import org.jbpm.model.definition.*;
import org.jbpm.model.definition.impl.DefinitionImpl;
import org.jbpm.model.execution.*;
import org.jbpm.model.execution.impl.*;
import org.jbpm.persistence.*;

public class ExecutionReadServiceImpl extends AbstractServiceImpl {

  public ExecutionReadServiceImpl( JbpmConfiguration jbpmConfiguration ) {
    super( jbpmConfiguration );
  }

	public ExecutionReadServiceImpl(ExecutionReadServiceImpl executionReadService, PersistenceSessionTx sessionTx) {
    super( executionReadService, sessionTx );
  }

	public Collection getTaskList(String targetActorId, Assembler assembler) {
    Collection tokens = null;

    PersistenceSession session = persistenceSessionFactory.createPersistenceSession();
    try {
      tokens = session.findTokensByActor(targetActorId);
      if ( assembler != null ) assembler.assemble( tokens );
    } finally {
      if ( session != null ) session.close();
    }

    return tokens;
  }

  public ProcessInstance getProcessInstance(Long processInstanceId, Assembler assembler) {
    ProcessInstance processInstance = null;

    PersistenceSession session = persistenceSessionFactory.createPersistenceSession();
    try {
      processInstance = (ProcessInstance) session.load(ProcessInstanceImpl.class, processInstanceId);
      if (assembler!=null) assembler.assemble( processInstance );
    } finally {
      if ( session != null ) session.close();
    }

    return processInstance;
  }

  public Token getToken(Long tokenId, Assembler assembler) {
    Token token = null;

    PersistenceSession session = persistenceSessionFactory.createPersistenceSession();
    try {
      token = (Token) session.load(TokenImpl.class, tokenId);
      if (assembler!=null) assembler.assemble( token );
    } finally {
      if ( session != null ) session.close();
    }

    return token;
  }

  public Map getVariables(Long tokenId) {
    Map variables = null;

    PersistenceSession session = persistenceSessionFactory.createPersistenceSession();
    try {
      TokenImpl token = (TokenImpl) session.load(TokenImpl.class, tokenId);
      variables = token.getVariables();
    } finally {
      if ( session != null ) session.close();
    }

    return variables;
  }
  
  public Definition getDefinition(Long definitionId, Assembler assembler) {
    Definition definition = null;

    PersistenceSession session = persistenceSessionFactory.createPersistenceSession();
    try {
      definition = (Definition) session.load( DefinitionImpl.class, definitionId );
      if (assembler!=null) assembler.assemble( definition );
    } finally {
      if ( session != null ) session.close();
    }

    return definition;
  }

  public Definition getLatestDefinition(String name) {
    Definition definition = null;

    PersistenceSession session = persistenceSessionFactory.createPersistenceSession();
    try {
      definition = session.findLatestDefinition( name );
    } finally {
      if ( session != null ) session.close();
    }

    return definition;
  }

  public Collection getLatestDefinitions() {
  	Map definitions = new HashMap();
    
    PersistenceSession session = persistenceSessionFactory.createPersistenceSession();
    try {
  		Iterator iter = session.findAllDefinitions().iterator();
  		while( iter.hasNext() ) {
  		  DefinitionImpl definition = (DefinitionImpl) iter.next();
  		  if ( definitions.containsKey( definition.getName() ) ) {
  		    DefinitionImpl other = (DefinitionImpl) definitions.get( definition.getName() );
  		    
  		    if ( (definition.getVersion() != null)
  		         && (other.getVersion() != null)
  		         && ( definition.getVersion().intValue() > other.getVersion().intValue() ) ) {
  		    	definitions.put( definition.getName(), definition );
  		    }
  		  } else {
  		    definitions.put( definition.getName(), definition );
  		  }
  		}
  	} finally {
  		if ( session != null ) session.close();
  	}
    
  	return new ArrayList( definitions.values() );
  }

  public byte[] getFile(Long processDefinitionId, String fileName) {
    byte[] bytes = null;
    
    PersistenceSession session = persistenceSessionFactory.createPersistenceSession();
    try {
      // load the process definition from the database
      DefinitionImpl definition = (DefinitionImpl) session.load( DefinitionImpl.class, processDefinitionId );

      // then use the persistence-mgr to retrieve the bytes
      bytes = fileMgr.retrieveBytes( definition.getId(), fileName );

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

    return bytes;
  }
}