spring webflow 2.x - 如何將alwaysGenerateNewNextKey設置爲false以使用單個快照

Question

團隊，我們將Spring webflow從1.x升級到2.4。

在SWF 1.x中，我們只對整個會話使用了一個flowExecutionKey，並禁用了後退導航。

在SWF 2.4，我們希望有相同的行爲，

我們可以通過配置MAX-執行的快照禁用快照0如下圖所示，

<webflow:flow-executor id="flowExecutor" flow-registry="flowRegistry"> 
    <webflow:flow-execution-repository max-executions="1" max-execution-snapshots="0"/> 
</webflow:flow-executor> 

但在導航，快照ID不斷增加(like e1s1, e1s2 ...)這是造成問題，當我們正在調查這個，

AbstractFlowExecutionRepository低於場，這有助於真正當在每個導航產生新snapshotId，

alwaysGenerateNewNextKey默認情況下爲true。

在SWF 1.x中，通過RepositoryType.SINGLEKEY有一個設置爲false的選項，但我們找不到在SWF 2.4中將此值設置爲false的任何等效方法。

請幫助，如果有辦法覆蓋"alwaysGenerateNewNextKey"

Answer 1

現在我知道這是醜陋的，但這裏是你可以做什麼：

使自己的​​和FlowElementAttribute複製，他們的名字MyFlowExecutorFactoryBean和MyFlowElementAttribute （將MyFlowExecutorFactoryBean中的引用從FlowElementAttribute更改爲MyFlowElementAttribute）。

在 MyFlowExecutorFactoryBean

設置要在executionRepository的屬性，如setAlwaysGenerateNewNextKey(true)

這裏是結果：

<bean id="flowExecutor" class="com.example.MyFlowExecutorFactoryBean "> 
    <property name="flowDefinitionLocator" ref="flowRegistry" /> 
    <property name="flowExecutionListenerLoader"> 
    <bean class="org.springframework.webflow.config.FlowExecutionListenerLoaderFactoryBean"> 
     <property name="listeners"> 
     <map> 
      <entry key-ref="yourFirstListener" value="*" /> 
      <entry key-ref="yourSecondListener" value="*" /> 
     </map> 
     </property> 
    </bean> 
    </property> 
</bean> 

我的天堂」：

public class MyFlowExecutorFactoryBean implements FactoryBean<FlowExecutor>, ApplicationContextAware, BeanClassLoaderAware, InitializingBean { 

    private static final String ALWAYS_REDIRECT_ON_PAUSE = "alwaysRedirectOnPause"; 

    private static final String REDIRECT_IN_SAME_STATE = "redirectInSameState"; 

    private FlowDefinitionLocator flowDefinitionLocator; 

    private Integer maxFlowExecutions; 

    private Integer maxFlowExecutionSnapshots; 

    private Set<MyFlowElementAttribute> flowExecutionAttributes; 

    private FlowExecutionListenerLoader flowExecutionListenerLoader; 

    private ConversationManager conversationManager; 

    private ConversionService conversionService; 

    private FlowExecutor flowExecutor; 

    private MvcEnvironment environment; 

    private ClassLoader classLoader; 

    /** 
    * Sets the flow definition locator that will locate flow definitions needed for execution. Typically also a 
    * {@link FlowDefinitionRegistry}. Required. 
    * @param flowDefinitionLocator the flow definition locator (registry) 
    */ 
    public void setFlowDefinitionLocator(FlowDefinitionLocator flowDefinitionLocator) { 
     this.flowDefinitionLocator = flowDefinitionLocator; 
    } 

    /** 
    * Set the maximum number of allowed flow executions allowed per user. 
    */ 
    public void setMaxFlowExecutions(int maxFlowExecutions) { 
     this.maxFlowExecutions = maxFlowExecutions; 
    } 

    /** 
    * Set the maximum number of history snapshots allowed per flow execution. 
    */ 
    public void setMaxFlowExecutionSnapshots(int maxFlowExecutionSnapshots) { 
     this.maxFlowExecutionSnapshots = maxFlowExecutionSnapshots; 
    } 

    /** 
    * Sets the system attributes that apply to flow executions launched by the executor created by this factory. 
    * Execution attributes may affect flow execution behavior. 
    * @param flowExecutionAttributes the flow execution system attributes 
    */ 
    public void setFlowExecutionAttributes(Set<MyFlowElementAttribute> flowExecutionAttributes) { 
     this.flowExecutionAttributes = flowExecutionAttributes; 
    } 

    /** 
    * Sets the strategy for loading the listeners that will observe executions of a flow definition. Allows full 
    * control over what listeners should apply to executions of a flow definition launched by the executor created by 
    * this factory. 
    */ 
    public void setFlowExecutionListenerLoader(FlowExecutionListenerLoader flowExecutionListenerLoader) { 
     this.flowExecutionListenerLoader = flowExecutionListenerLoader; 
    } 

    /** 
    * Sets the service type that manages conversations and effectively controls how state is stored physically when a 
    * flow execution is paused. 
    */ 
    public void setConversationManager(ConversationManager conversationManager) { 
     this.conversationManager = conversationManager; 
    } 

    // implementing ApplicationContextAware 

    @Override 
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { 
     environment = MvcEnvironment.environmentFor(applicationContext); 
    } 

    // implement BeanClassLoaderAware 

    @Override 
    public void setBeanClassLoader(ClassLoader classLoader) { 
     this.classLoader = classLoader; 
    } 

    // implementing InitializingBean 

    @Override 
    public void afterPropertiesSet() throws Exception { 
     Assert.notNull(flowDefinitionLocator, "The flow definition locator property is required"); 
     if (conversionService == null) { 
      conversionService = new DefaultConversionService(); 
     } 
     MutableAttributeMap<Object> executionAttributes = createFlowExecutionAttributes(); 
     FlowExecutionImplFactory executionFactory = createFlowExecutionFactory(executionAttributes); 
     DefaultFlowExecutionRepository executionRepository = createFlowExecutionRepository(executionFactory); 
     executionRepository.setMaxSnapshots(0); 
     executionRepository.setAlwaysGenerateNewNextKey(false); 
     executionFactory.setExecutionKeyFactory(executionRepository); 
     flowExecutor = new FlowExecutorImpl(flowDefinitionLocator, executionFactory, executionRepository); 
    } 

    // implementing FactoryBean 

    @Override 
    public Class<?> getObjectType() { 
     return FlowExecutor.class; 
    } 

    @Override 
    public boolean isSingleton() { 
     return true; 
    } 

    @Override 
    public FlowExecutor getObject() throws Exception { 
     return flowExecutor; 
    } 

    private MutableAttributeMap<Object> createFlowExecutionAttributes() { 
     LocalAttributeMap<Object> executionAttributes = new LocalAttributeMap<Object>(); 
     if (flowExecutionAttributes != null) { 
      for (MyFlowElementAttribute attribute : flowExecutionAttributes) { 
       executionAttributes.put(attribute.getName(), getConvertedValue(attribute)); 
      } 
     } 
     putDefaultFlowExecutionAttributes(executionAttributes); 
     return executionAttributes; 
    } 

    private void putDefaultFlowExecutionAttributes(LocalAttributeMap<Object> executionAttributes) { 
     if (!executionAttributes.contains(ALWAYS_REDIRECT_ON_PAUSE)) { 
      Boolean redirect = environment != MvcEnvironment.PORTLET; 
      executionAttributes.put(ALWAYS_REDIRECT_ON_PAUSE, redirect); 
     } 
     if (!executionAttributes.contains(REDIRECT_IN_SAME_STATE)) { 
      Boolean redirect = environment != MvcEnvironment.PORTLET; 
      executionAttributes.put(REDIRECT_IN_SAME_STATE, redirect); 
     } 
    } 

    private DefaultFlowExecutionRepository createFlowExecutionRepository(FlowExecutionFactory executionFactory) { 
     ConversationManager conversationManager = createConversationManager(); 
     FlowExecutionSnapshotFactory snapshotFactory = createFlowExecutionSnapshotFactory(executionFactory); 
     DefaultFlowExecutionRepository rep = new DefaultFlowExecutionRepository(conversationManager, snapshotFactory); 
     if (maxFlowExecutionSnapshots != null) { 
      rep.setMaxSnapshots(maxFlowExecutionSnapshots); 
     } 
     return rep; 
    } 

    private ConversationManager createConversationManager() { 
     if (conversationManager == null) { 
      conversationManager = new SessionBindingConversationManager(); 
      if (maxFlowExecutions != null) { 
       ((SessionBindingConversationManager) conversationManager).setMaxConversations(maxFlowExecutions); 
      } 
     } 
     return this.conversationManager; 
    } 

    private FlowExecutionSnapshotFactory createFlowExecutionSnapshotFactory(FlowExecutionFactory executionFactory) { 
     if (maxFlowExecutionSnapshots != null && maxFlowExecutionSnapshots == 0) { 
      maxFlowExecutionSnapshots = 1; 
      return new SimpleFlowExecutionSnapshotFactory(executionFactory, flowDefinitionLocator); 
     } else { 
      return new SerializedFlowExecutionSnapshotFactory(executionFactory, flowDefinitionLocator); 
     } 
    } 

    private FlowExecutionImplFactory createFlowExecutionFactory(AttributeMap<Object> executionAttributes) { 
     FlowExecutionImplFactory executionFactory = new FlowExecutionImplFactory(); 
     executionFactory.setExecutionAttributes(executionAttributes); 
     if (flowExecutionListenerLoader != null) { 
      executionFactory.setExecutionListenerLoader(flowExecutionListenerLoader); 
     } 
     return executionFactory; 
    } 

    // utility methods 

    private Object getConvertedValue(MyFlowElementAttribute attribute) { 
     if (attribute.needsTypeConversion()) { 
      Class<?> targetType = fromStringToClass(attribute.getType()); 
      ConversionExecutor converter = conversionService.getConversionExecutor(String.class, targetType); 
      return converter.execute(attribute.getValue()); 
     } else { 
      return attribute.getValue(); 
     } 
    } 

    private Class<?> fromStringToClass(String name) { 
     Class<?> clazz = conversionService.getClassForAlias(name); 
     if (clazz != null) { 
      return clazz; 
     } else { 
      try { 
       return ClassUtils.forName(name, classLoader); 
      } catch (ClassNotFoundException e) { 
       throw new IllegalArgumentException("Unable to load class '" + name + "'"); 
      } 
     } 
    } 

    class MyFlowElementAttribute { 

     /** 
     * The name of the attribute. 
     */ 
     private String name; 

     /** 
     * The value of the attribute before type-conversion. 
     */ 
     private String value; 

     /** 
     * The attribute type, optional, but necessary for type conversion. 
     */ 
     private String type; 

     public MyFlowElementAttribute(String name, String value, String type) { 
      Assert.hasText(name, "The name is required"); 
      Assert.hasText(value, "The value is required"); 
      this.name = name; 
      this.value = value; 
      this.type = type; 
     } 

     public String getName() { 
      return name; 
     } 

     public String getValue() { 
      return value; 
     } 

     public String getType() { 
      return type; 
     } 

     public boolean needsTypeConversion() { 
      return type != null && type.length() > 0; 
     } 
    } 
} 

現在在你的Webflow配置使用噸完全測試它，但它應該工作

Answer 2

個

謝謝，

我也延伸DefaultFlowExecutionRepository固定它，請參閱如果可能的話，希望它可以幫助別人，

<bean id="flowExecutionRepository" class="com.custom.module.SingleFlowExecutionRepository"> 
    <constructor-arg index="0" ref="conversationManager"/> 
    <constructor-arg index="1" ref="snapshotFactory"/> 
</bean> 

<bean id="flowExecutor" class="org.springframework.webflow.executor.FlowExecutorImpl"> 
    <constructor-arg index="0" ref="flowRegistry"/> 
    <constructor-arg index="1" ref="executionFactory" name="executionFactory"/> 
    <constructor-arg index="2" ref="flowExecutionRepository" name="executionRepository"/> 
</bean> 

而且

公共類SingleFlowExecutionRepository擴展DefaultFlowExecutionRepository {

public SingleFlowExecutionRepository(ConversationManager conversationManager, 
     FlowExecutionSnapshotFactory snapshotFactory) { 
    super(conversationManager, snapshotFactory);   
    /** 
    * Set to maintain single snapshot for a session. 
    */ 
    super.setAlwaysGenerateNewNextKey(false); 
}