Question

我在我的项目中使用了Spring 3的JSF 2，直到现在，我只是使用请求和会话范围。 我想对我的一些JSF bean使用视图范围（出于多种原因）。

问题是JSF ManagedBean必须实现 Serializable 接口及其所有属性。

我有一些难以获得Spring bean Serializables（例如：VilleService ...）因为它继续要求更多类可序列化，即使它不可能（hibernate类或mysql ...）。 p>

以下是一个例子：

public class VilleBean extends BaseBean implements Serializable {

    private Ville ville;
    private List<Ville> villes;
    private VilleService villeService;
    private PaysService paysService;
    private Pays pays;
    private List<Pays> payss;
    private PojoConverter<Pays> paysConverter = null;

    public VilleBean() {
        ville = new Ville();
        pays = new Pays();
    }

    public void setVilleService(VilleService villeService) {
        this.villeService = villeService;
    }

    public void setPaysService(PaysService paysService) {
        this.paysService = paysService;
    }

    // getters and setters for attributes : ville, pays, villes, payss


    public void addVilleAction() {
         ville.setPays(pays);
         villeService.create(ville);
    }

    public void deleteVilleAction(Ville ville) {
         villeService.delete(ville);
         villes = villeService.readAll();
    }

    public void updateVilleAction() {
         ville.setPays(pays);
         villeService.update(ville);
    }

    public PojoConverter<Pays> getPaysConverter() {
        this.paysConverter = new PojoConverter<Pays>(getPayss());
        return this.paysConverter;
    }
}



public abstract class BaseBean {
    protected FacesContext context = FacesContext.getCurrentInstance();
    protected MessageFactory msg;
    protected static final Logger log = Logger.getLogger(BaseBean.class);
}

POJO：

public class Ville implements Serializable {

    private int id;
    private String intitule;
    private Pays pays;

// setters and getters
}

public class Pays implements Serializable {

    private int id;
    private String intitule;

// setters and getters
}

服务界面：

public interface VilleService extends ICrud<Ville> {

}

服务Impl：

public class VilleServiceBase implements VilleService {

private IDao<Ville> dao;

// getter and setter for dao

@Override
public List<Ville> readAll() throws Exception {
       return dao.readAll();
}

@Override
public void create(Ville entity) throws Exception {
        dao.create(entity);
}
//****

Util：

public interface ICrud<T> {

public java.util.List readAll() throws Exception;
public void create(T entity) throws Exception;
public void update(T entity) throws Exception;
//****

public interface IDao<T> {

public java.util.List<T> readAll();
public T create(T entity);
//****

public class DaoBase<T> extends org.springframework.orm.hibernate3.support.HibernateDaoSupport implements IDao<T> {

private final Class<T> type;

public DaoBase(Class<T> type) {
      this.type = type;
}

@Override
public T load(int id) {
        return (T) this.getHibernateTemplate().get(this.type, new Integer(id));
}

@Override
public T create(T entity) {
     //****
       this.getHibernateTemplate().save(entity);
       return entity;
}

Spring beans：spring.xml：

 <!-- Ville Service Implementation  -->
<bean id="villeServiceBase" class="commun.ref.crud.VilleServiceBase">
    <property name="dao">
        <ref bean="villeDao"/>
    </property>
</bean>
<!-- Ville Service Proxy  -->
<bean id="villeService" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="target">
        <ref local="villeServiceBase"/>
    </property>
    <property name="proxyInterfaces">
        <value>commun.ref.crud.VilleService</value>
    </property>
    <property name="interceptorNames">
        <list>
            <value>manageableServiceTransactionInterceptor</value>
            <value>hibernateInterceptor</value>
        </list>
    </property>
</bean>

<bean id="villeDao" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="target">
        <bean class="smile.util.DaoBase">
            <constructor-arg>
                <value>commun.ref.Ville</value>
            </constructor-arg>
            <property name="sessionFactory">
                <ref bean="sessionFactory"/>
            </property>
        </bean>
    </property>
    <property name="proxyInterfaces">
        <value>smile.util.IDao</value>
    </property>
    <property name="interceptorNames">
        <list>
            <value>hibernateInterceptor</value>
        </list>
    </property>
</bean>

JSF配置：faces-config.xml：

<application>
    <el-resolver>org.springframework.web.jsf.el.SpringBeanFacesELResolver</el-resolver>
</application>

<application>
    <variable-resolver>
        org.springframework.web.jsf.DelegatingVariableResolver
    </variable-resolver>
</application>

    ******

<managed-bean> 
    <managed-bean-name>villeBean</managed-bean-name>
    <managed-bean-class>commun.ref.ui.VilleBean</managed-bean-class>
    <managed-bean-scope>view</managed-bean-scope>
    <managed-property>
        <property-name>villeService</property-name>
        <value>#{villeService}</value>
    </managed-property>
    <managed-property>
        <property-name>paysService</property-name>
        <value>#{paysService}</value>
    </managed-property>
</managed-bean>

请告诉我，该怎么办才能让它发挥作用。

Answer 1

在您不希望序列化或无法序列化的字段上，使用transient修饰符。例如：

private transient VilleService villeService;

当您使用MyFaces时，将此参数添加到web.xml：

<context-param>
  <param-name>org.apache.myfaces.SERIALIZE_STATE_IN_SESSION</param-name>
  <param-value>false</param-value>
</context-param>

据我所知，这个参数在Mojarra中是默认的false。这将禁用会话中的状态序列化。

Answer 2

如果您不使用会话钝化，则可以对非序列化字段使用transient属性。

例如：

private transient Connection connection;

无法使视图范围适用于我的Managed Beans

2 个答案: