import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
@Override
protected void initVariableTypes()
{
    super.initVariableTypes();
    // Add custom types before SerializableType
    if (customTypes != null)
    {
        int serializableIndex = variableTypes.getTypeIndex(SerializableType.TYPE_NAME);
        for (VariableType type : customTypes) 
        {
            variableTypes.addType(type, serializableIndex);
        }
    }
    
    // WOR-171: Replace string type by custom one to handle large text-values
    int stringIndex = variableTypes.getTypeIndex("string");
    variableTypes.removeType(variableTypes.getVariableType("string"));
    variableTypes.addType(new CustomStringVariableType(), stringIndex);
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
@Override
public void configure(ProcessEngineConfigurationImpl processEngineConfiguration)
{
    // There is an issue when using Activiti with Oracle. When workflow variables have a length greater then 2000 and smaller than 4001,
    // Activiti tries to store that as a String column, but the Oracle database column length (ACT_RU_VARIABLE.TEXT_, ACT_HI_VARINST.TEXT_) is 2000.
    // Since Activiti uses NVARCHAR as the column type which requires 2 bytes for every character, the maximum size Oracle allows for the column is
    // 2000 (i.e. 4000 bytes).

    // Replace the StringType and LongType to store greater than 2000 length variables as blob.
    VariableTypes variableTypes = processEngineConfiguration.getVariableTypes();

    VariableType stringType = new StringType(2000);
    int indexToInsert = replaceVariableType(variableTypes, stringType, 0);

    VariableType longStringType = new LongStringType(2001);
    replaceVariableType(variableTypes, longStringType, ++indexToInsert);
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
/**
 * Inserts the variableType in variableTypes at the given index. If variableType already exists, then it replaces the type at the location where it already
 * exists.
 *
 * @param variableTypes the variableTypes
 * @param variableTypeToReplace the variableType to insert
 * @param indexToInsert the index to insert variableType
 *
 * @return the index where variableType was inserted.
 */
private int replaceVariableType(VariableTypes variableTypes, VariableType variableTypeToReplace, int indexToInsert)
{
    int indexToInsertReturn = indexToInsert;

    VariableType existingVariableType = variableTypes.getVariableType(variableTypeToReplace.getTypeName());
    if (existingVariableType != null)
    {
        indexToInsertReturn = variableTypes.getTypeIndex(existingVariableType.getTypeName());

        variableTypes.removeType(existingVariableType);
    }
    variableTypes.addType(variableTypeToReplace, indexToInsertReturn);

    return indexToInsertReturn;
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
protected void initJpa() {
  if(jpaPersistenceUnitName!=null) {
    jpaEntityManagerFactory = JpaHelper.createEntityManagerFactory(jpaPersistenceUnitName);
  }
  if(jpaEntityManagerFactory!=null) {
    sessionFactories.put(EntityManagerSession.class, new EntityManagerSessionFactory(jpaEntityManagerFactory, jpaHandleTransaction, jpaCloseEntityManager));
    VariableType jpaType = variableTypes.getVariableType(JPAEntityVariableType.TYPE_NAME);
    // Add JPA-type
    if(jpaType == null) {
      // We try adding the variable right before SerializableType, if available
      int serializableIndex = variableTypes.getTypeIndex(SerializableType.TYPE_NAME);
      if(serializableIndex > -1) {
        variableTypes.addType(new JPAEntityVariableType(), serializableIndex);
      } else {
        variableTypes.addType(new JPAEntityVariableType());
      }        
    }
  }
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public void createVariableLocal(String variableName, Object value) {
  ensureVariableInstancesInitialized();
  
  if (variableInstances.containsKey(variableName)) {
    throw new ActivitiException("variable '"+variableName+"' already exists. Use setVariableLocal if you want to overwrite the value");
  }
  
  VariableTypes variableTypes = Context
    .getProcessEngineConfiguration()
    .getVariableTypes();
  
  VariableType type = variableTypes.findVariableType(value);
 
  VariableInstanceEntity variableInstance = VariableInstanceEntity.createAndInsert(variableName, type, value);
  initializeVariableInstanceBackPointer(variableInstance);
  variableInstances.put(variableName, variableInstance);
  
  setVariableInstanceValue(value, variableInstance);
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
protected void updateVariableInstance(VariableInstanceEntity variableInstance, Object value, ExecutionEntity sourceActivityExecution) {

     // type should be changed
 if ((variableInstance != null) && (!variableInstance.getType().isAbleToStore(value))) {
	    VariableTypes variableTypes = Context
	    	      .getProcessEngineConfiguration()
	    	      .getVariableTypes();
	    VariableType newType = variableTypes.findVariableType(value);
	    variableInstance.setValue(null);
	    variableInstance.setType(newType);
	    variableInstance.forceUpdate();
  }
   variableInstance.setValue(value);

   Context.getCommandContext().getHistoryManager()
     .recordHistoricDetailVariableCreate(variableInstance, sourceActivityExecution, isActivityIdUsedForDetails());
   
   Context.getCommandContext().getHistoryManager()
     .recordVariableUpdate(variableInstance);
 }
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
protected VariableInstanceEntity createVariableInstance(String variableName, Object value, ExecutionEntity sourceActivityExecution) {
  VariableTypes variableTypes = Context
    .getProcessEngineConfiguration()
    .getVariableTypes();
  
  VariableType type = variableTypes.findVariableType(value);
 
  VariableInstanceEntity variableInstance = VariableInstanceEntity.createAndInsert(variableName, type, value);
  initializeVariableInstanceBackPointer(variableInstance);
  variableInstances.put(variableName, variableInstance);
  
  // Record historic variable
  Context.getCommandContext().getHistoryManager()
    .recordVariableCreate(variableInstance);

  // Record historic detail
  Context.getCommandContext().getHistoryManager()
    .recordHistoricDetailVariableCreate(variableInstance, sourceActivityExecution, isActivityIdUsedForDetails());

  return variableInstance;
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
/**
 * Activiti by default configures StringType and LongStringType VariableType in configuration.
 * This method tests the scenarios where no StringType and LongStringType is already configured in configuration.
 */
@Test
public void testNoStringAndLongStringType() throws Exception
{
    SpringProcessEngineConfiguration configuration = new SpringProcessEngineConfiguration();
    configuration.setVariableTypes(new DefaultVariableTypes());
    
    herdProcessEngineConfigurator.configure(configuration);
    VariableType type = configuration.getVariableTypes().findVariableType(StringUtils.repeat("a", 2000));
    assertEquals(StringType.class, type.getClass());
    
    type = configuration.getVariableTypes().findVariableType(StringUtils.repeat("a", 2001));
    assertEquals(LongStringType.class, type.getClass());
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public static VariableInstanceEntity createAndInsert(String name, VariableType type, Object value) {
  VariableInstanceEntity variableInstance = create(name, type, value);

  Context
    .getCommandContext()
    .getDbSqlSession()
    .insert(variableInstance);

  return variableInstance;
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public static VariableInstanceEntity create(String name, VariableType type, Object value) {
  VariableInstanceEntity variableInstance = new VariableInstanceEntity();
  variableInstance.name = name;
  variableInstance.type = type;
  variableInstance.setValue(value);
  
  return variableInstance;
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public Object getResult(ResultSet rs, String columnName) throws SQLException {
  String typeName = rs.getString(columnName);
  VariableType type = getVariableTypes().getVariableType(typeName);
  if (type == null) {
    throw new ActivitiException("unknown variable type name " + typeName);
  }
  return type;
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public void initialize(VariableTypes types) {
  if(variableInstanceEntity == null) {
    VariableType type = types.findVariableType(value);
    if(type instanceof ByteArrayType) {
      throw new ActivitiException("Variables of type ByteArray cannot be used to query");
    } else if(type instanceof JPAEntityVariableType && operator != QueryOperator.EQUALS) {
      throw new ActivitiException("JPA entity variables can only be used in 'variableValueEquals'");
    } else {
      // Type implementation determines which fields are set on the entity
      variableInstanceEntity = VariableInstanceEntity.create(name, type, value);
    }
  }
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public static VariableInstanceEntity createAndInsert(String name, VariableType type, Object value) {
  VariableInstanceEntity variableInstance = create(name, type, value);

  Context.getCommandContext()
    .getDbSqlSession()
    .insert(variableInstance);

  return variableInstance;
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public static VariableInstanceEntity create(String name, VariableType type, Object value) {
  VariableInstanceEntity variableInstance = new VariableInstanceEntity();
  variableInstance.name = name;
  variableInstance.type = type;
  variableInstance.setValue(value);
  return variableInstance;
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public VariableType getResult(ResultSet rs, String columnName) throws SQLException {
  String typeName = rs.getString(columnName);
  VariableType type = getVariableTypes().getVariableType(typeName);
  if (type == null && typeName != null) {
    throw new ActivitiException("unknown variable type name " + typeName);
  }
  return type;
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public void initialize(VariableTypes types) {
  if(variableInstanceEntity == null) {
    VariableType type = types.findVariableType(value);
    if(type instanceof ByteArrayType) {
      throw new ActivitiIllegalArgumentException("Variables of type ByteArray cannot be used to query");
    } else if(type instanceof JPAEntityVariableType && operator != QueryOperator.EQUALS) {
      throw new ActivitiIllegalArgumentException("JPA entity variables can only be used in 'variableValueEquals'");
    } else {
      // Type implementation determines which fields are set on the entity
      variableInstanceEntity = VariableInstanceEntity.create(name, type, value);
    }
  }
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public void setCustomTypes(List<VariableType> customTypes)
{
    this.customTypes = customTypes;
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public List<VariableType> getCustomPreVariableTypes() {
  return customPreVariableTypes;
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public ProcessEngineConfigurationImpl setCustomPreVariableTypes(List<VariableType> customPreVariableTypes) {
  this.customPreVariableTypes = customPreVariableTypes;
  return this;
}
 

import org.activiti.engine.impl.variable.VariableType; //导入依赖的package包/类
public List<VariableType> getCustomPostVariableTypes() {
  return customPostVariableTypes;
}