关于struts2的checkboxlist、select等标签发生could not be resolved as a collection/array/map/enumeration/iterator type异常的记录

1 刚进入该界面的时候发生错误，原因是 list="roles"中的这个集合是空的，导致错误

解决办法很简单，不能让list为空

2
刚进入该界面的时候list是有数据的，当点击提交等按钮的时候，数据被提交到后台,如果配置了验证框架或者在action中写了validate方法，校验没有通过，未走action，直接返回了input，又指定回了当前界面。
此时的checkboxlist中的list丢失了，导致了如上错误（这个错误提示的不太友好，让人认为是类转换错误）

解决办法是把初始化list的工作放到prepare拦截器中，因为prepare是在validate拦截器之前执行，即实现prepareble接口：

publicclass RoleAction extends ActionSupport implements Preparable{
    @Override
    publicvoid prepare() throws Exception {
        //初始化list
    }
}

意思就是你这个类实现接口Preparable里的prepare，把原先获取list放入到prepare()方法中，然后在原先List语句上调用这个方法就OK

package com.ccse.frame.action.rule;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import com.ccse.core.SeqManager;
import com.ccse.core.command.QueryFilter;
import com.ccse.core.command.sql.SqlQueryFilter;
import com.ccse.core.command.sql.SqlSpellerDbType;
import com.ccse.core.util.BeanUtil;
import com.ccse.core.web.action.BaseAction;
import com.ccse.frame.model.base.BaseUser;
import com.ccse.frame.model.rule.RuleAutogeneration;
import com.ccse.frame.service.rule.RuleAutogenerationService;
import com.ccse.oa.util.ContextUtil;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.opensymphony.xwork2.Preparable;

/**
 * 证书自动生成规则
 *
 * @author hackermi
 * @date 2013-7-3 下午02:33:30
 */
public class RuleAutogenerationAction extends BaseAction  implements Preparable{
	/**
	 *
	 */
	private static final long serialVersionUID = 1L;

	@Resource
	private RuleAutogenerationService ruleAutogenerationService;
	private RuleAutogeneration ruleAutogeneration;

	private String ruleId;
	//创建新版本
	private boolean ruleRoot = false;

	public boolean getRuleRoot() {
		return ruleRoot;
	}

	public void setRuleRoot(boolean ruleRoot) {
		this.ruleRoot = ruleRoot;
	}

	public String getRuleId() {
		return ruleId;
	}

	public void setRuleId(String ruleId) {
		this.ruleId = ruleId;
	}

	public RuleAutogeneration getRuleAutogeneration() {
		return ruleAutogeneration;
	}

	public void setRuleAutogeneration(RuleAutogeneration ruleAutogeneration) {
		this.ruleAutogeneration = ruleAutogeneration;
	}

	/**
	 * 显示列表
	 */
	public String list() {

		QueryFilter filter = new QueryFilter(getReq());
		List<RuleAutogeneration> list = ruleAutogenerationService
				.getAll(filter);

		Type type = new TypeToken<List<RuleAutogeneration>>() {
		}.getType();
		StringBuffer buff = new StringBuffer("{\"total\":").append(
				filter.getPagingBean().getTotalItems()).append(",\"rows\":");

		Gson gson = new Gson();
		buff.append(gson.toJson(list, type));
		buff.append("}");

		jsonString = buff.toString();

		return SUCCESS;
	}

	/**
	 * 批量删除
	 *
	 * @return
	 */
	public String multiDel() {

		String ids = getReq().getParameter("ids");
		if (ids != null) {
			for (String id : ids.split(",")) {
				ruleAutogenerationService.remove(id);
			}
		}
		jsonString = "{success:true}";
		return SUCCESS;
	}

	public void prepare() throws Exception {
		// TODO Auto-generated method stub
		List sysTypes=ruleAutogenerationService.getsysType();//所属类型
		List sysType=new ArrayList();
		for (int i = 0; i < sysTypes.size(); i++) {
			System.out.println(sysTypes.get(i));
		}
		Iterator<?> itr = sysTypes.iterator();
		while (itr.hasNext()) {
		Map<?, ?> nextObj = (Map<?, ?>) itr.next();
		String value=(String) nextObj.get("ywcode");
		sysType.add(value.trim());
//		sysType.add((String)nextObj.get("ywcode"));
		}

		this.getRequest().put("sysType", sysType);
	}

	/**
	 * 新增SAMIS
	 *
	 * @return
	 */
	public String getSAMIS() {
		try {
			// List sourCeNames=ruleAutogenerationService.getSourCeName();
			// this.getRequest().put("sourcenames", sourCeNames);//系统类型

			String ruleRoot = this.getReq().getParameter("ruleRoot");// 是否是创建新版本
			if (ruleId != null && !"".equals(ruleId)) {
				ruleAutogeneration = ruleAutogenerationService.get(ruleId);
				if (ruleRoot != null && !"".equals(ruleRoot)) {
					ruleAutogeneration.setRuleRoot(ruleRoot);
					this.getReq().setAttribute("ruleRoot", ruleRoot);
				}
			}
			this.prepare();
			this.setForwardPage("/pages/rule/RuleAutogenerationSAMISForm.jsp");
			jsonString = null;
			return SUCCESS;
		} catch (Exception e) {
			e.printStackTrace();
			return this.err(e);
		}
	}

	/**
	 * 新增SSMIS
	 *
	 * @return
	 */
	public String getSSMIS() {
		try {
			 //List sourCeNames=ruleAutogenerationService.getSourCeName();
			// this.getRequest().put("sourcenames", sourCeNames);//所属系统
			String ruleRoot = this.getReq().getParameter("ruleRoot");// 是否是创建新版本
			if (ruleId != null && !"".equals(ruleId)) {
				ruleAutogeneration = ruleAutogenerationService.get(ruleId);
				if (ruleRoot != null && !"".equals(ruleRoot)) {
					ruleAutogeneration.setRuleRoot(ruleRoot);
					this.getReq().setAttribute("ruleRoot", ruleRoot);
				}
			}
			this.setForwardPage("/pages/rule/RuleAutogenerationSSMISForm.jsp");
			jsonString = null;
			return SUCCESS;
		} catch (Exception e) {
			e.printStackTrace();
			return this.err(e);
		}
	}

	/**
	 * 添加及保存操作
	 */
	public String save() {
		try {
			BaseUser baseUser = ContextUtil.getCurrentUser();
			//新增
			if (ruleAutogeneration.getRuleId() == null || "".equals(ruleAutogeneration.getRuleId())) {
				ruleAutogeneration.setRuleId(null);
				ruleAutogeneration.setRuleVersion("1.0");
				ruleAutogeneration.setRuleRoot(SeqManager.getSeqMang().getUUID());//根节点
				ruleAutogeneration.setLastUpdateTime(new Date());// 修改时间
				ruleAutogeneration.setCreTime(new Date());// 创建时间
				ruleAutogeneration.setCreUserId(baseUser.getId());// 创建人ID
				ruleAutogeneration.setCreUserName(baseUser.getUsername());// 创建人姓名
				ruleAutogenerationService.save(ruleAutogeneration);

			} else {
				RuleAutogeneration orgRuleAutogeneration = ruleAutogenerationService.get(ruleAutogeneration.getRuleId());
				if(null != orgRuleAutogeneration) {
					BeanUtil.copyNotNullProperties(orgRuleAutogeneration, ruleAutogeneration);
					//创建新版本
					if (ruleRoot) {
						ruleAutogenerationService.evict(orgRuleAutogeneration);//清空旧对象的缓存
						orgRuleAutogeneration.setRuleId(null);
						orgRuleAutogeneration.setRuleVersion(ruleAutogenerationService.getBigVersion(orgRuleAutogeneration));
						orgRuleAutogeneration.setLastUpdateTime(new Date());//修改时间
						orgRuleAutogeneration.setCreTime(new Date());//创建时间
						orgRuleAutogeneration.setCreUserName(baseUser.getUsername());
						ruleAutogenerationService.save(orgRuleAutogeneration);
					} else {
						//修改
						orgRuleAutogeneration.setLastUpdateTime(new Date());// 修改时间
						orgRuleAutogeneration.setUpdateUserId(baseUser.getId());//修改创建人ID
						orgRuleAutogeneration.setUpdateUserName(baseUser.getUsername());// 修改人姓名
						ruleAutogenerationService.save(orgRuleAutogeneration);
					}
				}else{
					throw new RuntimeException("对象不存在");
				}
			}
		} catch (Exception ex) {
			logger.error(ex.getMessage());
			ex.printStackTrace();
		}
		setJsonString("{success:true}");
		if (ruleAutogeneration.getSysId().equals("SAMIS")) {
			this.setForwardPage("/pages/rule/RuleAutogenerationSAMISForm.jsp");
		} else if (ruleAutogeneration.getSysId().equals("SSMIS")) {
			this.setForwardPage("/pages/rule/RuleAutogenerationSSMISForm.jsp");
		}
		return SUCCESS;

	}

}