Java @viewscope bean意外存活

我正在开发一个视图，它由对象创建表单和现有对象列表creablocco.xhtml组成：

因此，当一个流的新实例启动时，应该从头开始重新创建它

我已经试过使用示波器了，但没有解决问题

为了完整起见，我提到了BlocchiBean对象之前的注释：

@Component("blocchiBean")
@ViewScoped
public class BlocchiBean implements Serializable {  

我的目标是将组件名与视图和流中使用的bean名相匹配。不幸的是，这个注释也不能解决问题。

我找到了补救办法。
我还不能完全解释为什么我的问题中提供的解决方案不起作用，但至少我找到了一个正确的解决方案

我在流中声明了一个流变量：

<var name="blocchiBean" class="com.infoone.siglo.viewbeans.BlocchiBean" />

对于那些这样做的人，不要在xml配置文件中将其显式声明为bean。它必须是一个弹簧流量变量，而不是其他变量

它现在起作用了。无论如何，不要期望SpringWebFlow在同一个流实例中始终使用相同的BlocchiBean对象，即使它本身是流范围的（它是一个流变量，因此它是流范围的）。
实际上，如果运行调试器并查看对象ID，您会发现SpringWebFlow在同一个流实例中使用不同的实例。一开始听起来很奇怪，但最终它还是起作用了：事实上，每次对bean实例进行垃圾收集时，它的状态都会被正确地保存在“某处”，这样就可以在实例化之后，通过它的setter方法设置同一流执行中的下一个实例的状态

---

显然，如果流的另一个实例启动，将构造一个新的流变量，并且不会通过调用其setter方法来更改其状态。换句话说，它的行为将与预期的FlowScope变量的行为相同。

简单猜测一下：组件是spring注释，ViewScope是JSF注释。因此，当Spring实例化bean时，它使用默认的“singleton”作用域。

package com.infoone.siglo.viewbeans;

import java.io.Serializable;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentSkipListSet;

import javax.annotation.PostConstruct;
import javax.faces.bean.ViewScoped;

import org.icefaces.ace.component.column.Column;
import org.icefaces.ace.component.datatable.DataTable;
import org.icefaces.ace.event.SelectEvent;
import org.icefaces.ace.event.UnselectEvent;
import org.icefaces.ace.model.table.RowState;
import org.icefaces.ace.model.table.RowStateMap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.infoone.siglo.viewbeans.lazyLoaders.BlocchiLazyLoader;

@Component
@ViewScoped
public class BlocchiBean implements Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = -7007046069743684498L;

    @Autowired
    private transient BlocchiLazyLoader blocchi;
    private DataTable table;
    private RowStateMap stateMap;
    private Set<CreaBloccoBean> righeSelezionate;
    private boolean modificaInCorso;

    public BlocchiBean()
    {
    }

    @SuppressWarnings("unused")
    @PostConstruct
    private void initBlocchi()
    {
        stateMap = new RowStateMap();
        stateMap.setAllSelectable(true);

        righeSelezionate = new ConcurrentSkipListSet<CreaBloccoBean>();

        blocchi.setRowCount(blocchi.getPageSize());

        modificaInCorso = false;
    }

    //BlocchiLazyLoader blocchi
    public void setBlocchi(BlocchiLazyLoader blocchi) {
        this.blocchi = blocchi;
    }   
    public BlocchiLazyLoader getBlocchi() {
        return blocchi;
    }

    //RowStateMap stateMap
    public RowStateMap getStateMap() {
        return stateMap;
    }
    public void setStateMap(RowStateMap stateMap) {
        this.stateMap = stateMap;
    }

    //DataTable table
    public DataTable getTable() {
        return table;
    }
    public void setTable(DataTable table) {
        this.table = table;
    }

    //Selection listeners
    public void selectListener(SelectEvent event) {
        Object[] oggettiSelezionati = event.getObjects();
        for (Object oggettoSelezionato : oggettiSelezionati) {
            CreaBloccoBean bloccoSelezionato = (CreaBloccoBean) oggettoSelezionato;
            righeSelezionate.add(bloccoSelezionato);
        }
    }

    public void deselectListener(UnselectEvent event) {
        Object oggettoDeselezionato = event.getObject();
        CreaBloccoBean bloccoDeselezionato = (CreaBloccoBean) oggettoDeselezionato;
        righeSelezionate.remove(bloccoDeselezionato);
    }

    //List<CreaBloccoBean> righeSelezionate
    public List<CreaBloccoBean> getRigheSelezionate() {
        CreaBloccoBean[] array = new CreaBloccoBean[righeSelezionate.size()];
        array = righeSelezionate.toArray(array);
        return Arrays.asList(array);
    }
    public void setRigheSelezionate(List<CreaBloccoBean> righeSelezionate) {
        this.righeSelezionate.clear();
        this.righeSelezionate.addAll(righeSelezionate);
    }

    public boolean isModificaInCorso() {
        return modificaInCorso;
    }

    public void setModificaInCorso(boolean modificaInCorso) {
        this.modificaInCorso = modificaInCorso;
    }

    //Abilitazione dell'editing
    public void abilitaModifica() {
        if (!righeSelezionate.isEmpty())
        {
            modificaInCorso = true;
            List<Column> colonne = table.getColumns();
            for (Object oggettoCorrente : stateMap.getSelected()) {
                CreaBloccoBean beanCorrente = (CreaBloccoBean) oggettoCorrente;
                RowState statoCorrente = stateMap.get(beanCorrente);
                if (righeSelezionate.contains(beanCorrente)) {
                    for (Column colonna : colonne) {
                        statoCorrente.addActiveCellEditor(colonna.getCellEditor());
                    }
                }
            }
        }
    }
}

@Component
@ViewScoped
public class BlocchiBean implements Serializable {  

@Component("blocchiBean")
@ViewScoped
public class BlocchiBean implements Serializable {  

<var name="blocchiBean" class="com.infoone.siglo.viewbeans.BlocchiBean" />

package com.infoone.siglo.viewbeans;
//imports
public class BlocchiBean implements Serializable {