validatormanager.java.svn-base

EasyJWeb是基于java技术

package com.easyjf.web.validate;

import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;

import com.easyjf.container.annonation.Field;
import com.easyjf.container.annonation.FormPO;
import com.easyjf.util.StringUtils;
import com.easyjf.web.core.FrameworkEngine;
import com.easyjf.web.exception.FrameworkException;

/**
 * 系统验证器管理器，负责管理系统中的注册的验证器，验证对象，以及错误对象等。其它对象通过调用该对象可以直接使用验证功能。
 * 
 * @author 大峡
 * 
 */
public class ValidatorManager {

	/**
	 * 用来存放系统中的注册的验证器类，默认情况会自动使用类名作为验证器，系统会自动搜索系统中的所有验证器，并注册到该Map中。
	 */
	private java.util.Map<String, Validator> validators = new java.util.HashMap<String, Validator>();

	/**
	 * 用来存放验证器的类型，特别是那种需要每次创建，用户自定义的验证器。
	 */
	private java.util.Map<String, Class> validatorsType = new java.util.HashMap<String, Class>();

	/**
	 * 缓存验证目标对象
	 */
	private java.util.Map<Object, TargetObject> targetObjects = new java.util.HashMap<Object, TargetObject>();

	/**
	 * 缓存记录验证类型，如对于Person对象，name为person，值为com.easyjweb.demo.domain.Person
	 */
	private java.util.Map<String, Class> targetTypes = new java.util.HashMap<String, Class>();

	private static final Logger logger = Logger
			.getLogger(ValidatorManager.class);

	/**
	 * 
	 */
	private static java.lang.ThreadLocal<Map> errorsWrapper;

	/**
	 * 存放验证错误结果
	 */
	private java.lang.ThreadLocal<Errors> errors;

	/**
	 * 重新初始化验证器管理器，自动扫描系统中的验证器，并注册到validators中，同时将清除已管理的各种验证器对象。
	 * 
	 */
	public void reload() {
		validatorsType.clear();
		validators.clear();
		targetObjects.clear();
		if (errors != null)
			errors = null;
		if (errorsWrapper != null)
			errorsWrapper = null;
		init();
	}

	/**
	 * 初始化系统中验证器
	 * 
	 */
	protected void init() {
		Validators vs = new Validators();
		this.registerValidator("required", vs.new RequiredValidator());
		this.registerValidator("email", vs.new EmailValidator());
		this.registerValidator("url", vs.new URLValidator());
		this.registerValidator("string", vs.new StringValidator());
		this.registerValidator("range", vs.new RangeValidator());
		this.registerValidator("regex", vs.new RegexpValidator());
	}

	/**
	 * 从验证管理器中返回验证器
	 * 
	 * @param name
	 *            验证器的逻辑名称，如string、required、range等
	 * @return 获取系统中注册的指定名称的验证器
	 */
	public Validator getValidator(String name) {
		if (!StringUtils.hasLength(name))
			return null;
		String key = name.toLowerCase();
		Validator v = validators.get(key);
		/**
		 * 此处让资源管理器进一步到容器中进行查找，造成ValidatorManager与FrameworkEngine严重耦合
		 */
		if (FrameworkEngine.getContainer() != null) {
			Object tv = FrameworkEngine.getContainer().getBean(name);
			if (tv != null && tv instanceof Validator) {
				this.registerValidator(name, (Validator) tv);
				v = (Validator) tv;
			}
		}
		if (v == null)
			throw new FrameworkException("系统中没有注册名为" + name + "的验证器，请检查！");
		return v;
	}

	/**
	 * 根据名称从验证器类别列表中创建验证器类,这个方法很少使用。
	 * 
	 * @param name
	 *            验证器的类型
	 * @return 获取系统注意的指定类型的验证器
	 */
	public Validator getValidatorByType(String name) {
		if (!StringUtils.hasLength(name))
			return null;
		String key = name.toLowerCase();
		Class vclz = validatorsType.get(key);
		Validator v = null;
		if (vclz != null) {
			try {
				vclz.newInstance();
			} catch (Exception e) {
				throw new FrameworkException("无法初始化类型为" + vclz
						+ "的验证器，请确认该验证器是否包含默认的构造函数！", e);
			}
		} else
			throw new FrameworkException("系统中没有注册名为" + name + "的验证器，请检查！");
		return v;

	}

	/**
	 * 读取验证结果错误对象
	 * 
	 * @return 返回验证错误或异常结果
	 */
	public Errors getErrors() {
		if (errors == null || errors.get() == null) {
			errors = new java.lang.ThreadLocal<Errors>();
			Errors errs = new Errors();
			errors.set(errs);
		}
		return errors.get();
	}

	public void cleanErrors() {
		errors = null;
	}

	/**
	 * 返回系统中的所有验证器
	 * 
	 * @return 系统中的所有验证器类型
	 */
	public java.util.Collection<Class> getValidatorsType() {
		return validatorsType.values();
	}

	/**
	 * 注册验证器
	 * 
	 * @param name
	 *            验证器名称
	 * @param validator
	 *            验证器
	 */
	public void registerValidator(String name, Validator validator) {
		if (!StringUtils.hasLength(name))
			return;
		String key = name.toLowerCase();
		validators.put(key, validator);
	}

	/**
	 * 注册验证器类
	 * 
	 * @param name
	 * @param clz
	 */
	public void registerValidator(String name, Class clz) {
		if (!StringUtils.hasLength(name))
			return;
		String key = name.toLowerCase();
		if (Validator.class.isAssignableFrom(clz))
			validatorsType.put(key, clz);
	}

	/**
	 * 返回系统中注册的所有验证对象
	 * 
	 * @return 得到目标验证对象的
	 */
	public Collection<TargetObject> getTargetTypes() {
		return targetObjects.values();
	}

	/**
	 * 得到某一种类型的验证对象
	 * 
	 * @param type
	 * @return 目标验证对象集合
	 */
	public java.util.Collection<TargetObject> getValidateObjects(
			ValidateType type) {
		return targetObjects.values();
	}

	/**
	 * 往系统中添加验证对象
	 * 
	 * @param object
	 */
	public void addValidateObject(TargetObject object) {
		targetObjects.put(object.getTarget(), object);
	}

	/**
	 * 返回系统中的验证对象
	 * 
	 * @param obj
	 * @return 得到obj对应的验证目标对象
	 */
	public TargetObject getValidateObject(Object obj) {
		return targetObjects.get(obj);
	}

	/**
	 * 创建可以包含多个验证结果的验证器对象
	 * 
	 * @param obj
	 *            验证主体对象
	 * @return 验证主体对象的验证结果
	 */
	public Errors createValidateMulitErrors(Object obj) {
		if (errorsWrapper == null) {
			errorsWrapper = new java.lang.ThreadLocal<Map>();
			errorsWrapper.set(new java.util.HashMap());
		}
		Errors errs = (Errors) errorsWrapper.get().get(obj);
		if (errs == null) {
			errs = new Errors();
			errorsWrapper.get().put(obj, errs);
		}
		return errs;
	}

	/**
	 * 检测一个属性是否需要进行验证，若检测到属性，则根据ceateInCache参数把验证对象加自动加入到系统缓存中
	 * 
	 * @param property
	 *            要检测的属性
	 * @return 若存在指定属性的验证对象信息，则返回该对象，否则返回null
	 */
	public TargetObject findValidateObject(
			java.beans.PropertyDescriptor property) {
		TargetObject validateObject = null;
		// java.util.List<com.easyjf.web.tools.annotations.Validator>
		// vds = new
		// java.util.ArrayList<com.easyjf.web.tools.annotations.Validator>();
		java.util.List ret = findValidators1(property);
		java.util.Iterator it = ret.iterator();
		while (it.hasNext()) {
			Map map = (Map) it.next();
			java.util.Iterator vsi = map.entrySet().iterator();
			while (vsi.hasNext()) {
				Map.Entry en = (Map.Entry) vsi.next();
				java.util.List<com.easyjf.container.annonation.Validator> vds = (List) en