formhandler.java

EasyJWeb是基于java技术

package com.easyjf.web.core;

import java.beans.PropertyDescriptor;
import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;

import com.easyjf.beans.BeanUtils;
import com.easyjf.beans.BeanWrapper;
import com.easyjf.container.Container;
import com.easyjf.container.annonation.FormPO;
import com.easyjf.container.annonation.InnerProperty;
import com.easyjf.container.annonation.MultiPOLoad;
import com.easyjf.container.annonation.OverrideProperty;
import com.easyjf.container.annonation.Overrides;
import com.easyjf.container.annonation.POLoad;
import com.easyjf.util.StringUtils;
import com.easyjf.web.POLoadDao;
import com.easyjf.web.validate.TargetObject;
import com.easyjf.web.validate.ValidateType;
import com.easyjf.web.validate.ValidatorManager;

/**
 * 该类从FrameworkEngine中抽出，主要负责处理WebForm中的数据到Program Object对象中数据的转换 包括验证
 * 
 * @author 大峡
 * 
 */
public class FormHandler {

	private Container container;

	private ValidatorManager validateManager;

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

	public FormHandler(Container container, ValidatorManager validateManager) {
		this.container = container;
		this.validateManager = validateManager;
	}

	public boolean checkPoWriteEnabled(Object obj,
			java.beans.PropertyDescriptor property) {
		boolean ret = true;
		/*
		 * FormPO formPO = obj.getClass().getAnnotation(FormPO.class); if
		 * (formPO != null) { String injectEnabled = formPO.inject(); if
		 * (StringUtils.hasLength(injectEnabled)) { ret = ("," + injectEnabled +
		 * ",").indexOf("," + property.getName() + ",") >= 0;// 找不到，则不注入 } else {
		 * String disInject = formPO.disInject(); if
		 * (StringUtils.hasLength(disInject)) ret = ("," + disInject +
		 * ",").indexOf("," + property.getName() + ",") < 0;// 找到，则不注入 } }
		 */
		ret = checkFormPOWriteEnabled(obj.getClass(), property);
		// 如果允许注入，则进一步判断Field标签的editable属性值
		if (ret) {
			com.easyjf.container.annonation.Field f = findAnnotation(
					com.easyjf.container.annonation.Field.class, obj, property);
			if (f != null) {
				if (!f.writeable())
					ret = false;// 如果writeable设置成false，则表示不准注入
			}
		}
		return ret;
	}

	public boolean checkFormPOWriteEnabled(Class clz,
			java.beans.PropertyDescriptor property) {
		boolean ret = true;
		FormPO formPO = (FormPO) clz.getAnnotation(FormPO.class);
		boolean haveFound = false;
		if (formPO != null) {
			String injectEnabled = formPO.inject();
			
			if (StringUtils.hasLength(injectEnabled)) {
				ret = ("," + injectEnabled + ",").indexOf(","
						+ property.getName() + ",") >= 0;// 找不到，则不注入
				if (ret)
					haveFound = true;
			} else {
				String disInject = formPO.disInject();				
				if (StringUtils.hasLength(disInject))
					ret = ("," + disInject + ",").indexOf(","
							+ property.getName() + ",") < 0;// 找到，则不注入
				if (!ret)
					haveFound = true;
			}		
		}
		if (!haveFound && clz.getSuperclass() != Object.class)
			ret = checkFormPOWriteEnabled(clz.getSuperclass(), property);
		return ret;
	}

	public boolean checkPoReadEnabled(Object obj,
			java.beans.PropertyDescriptor property) {
		boolean ret = true;
		FormPO formPO = obj.getClass().getAnnotation(FormPO.class);
		if (formPO != null) {
			String disRead = formPO.disRead();
			if (StringUtils.hasLength(disRead)) {
				ret = ("," + disRead + ",").indexOf("," + property.getName()
						+ ",") < 0;// 找不到，则允许读
			}
		}
		// 如果允许注入，则进一步判断Field标签的editable属性值
		if (ret) {
			com.easyjf.container.annonation.Field f = findAnnotation(
					com.easyjf.container.annonation.Field.class, obj, property);
			if (f != null) {
				if (!f.readable())
					ret = false;// 如果writeable设置成false，则表示不准注入
			}
		}
		return ret;
	}

	/**
	 * 读取一个类中属性或方法的标签，该方法首先从属性访问方法中查找标签定义，若找不到，则进一步通过对象的Field属性查找标签定义
	 * 
	 * @param <A>
	 * @param annotationClass
	 *            指定的标签类型
	 * @param obj
	 *            目标对象
	 * @param property
	 *            具体的属性
	 * @return 如果找到指定的标签，则直接返回，若没找到，则返回null
	 */
	public static <A extends Annotation> A findAnnotation(
			Class<A> annotationClass, Object obj, PropertyDescriptor property) {
		A ret = null;
		if (property.getWriteMethod() != null)
			ret = property.getWriteMethod().getAnnotation(annotationClass);// 查找setter方法
		if (ret == null && property.getReadMethod() != null)
			ret = property.getReadMethod().getAnnotation(annotationClass);// 查找getter方法
		if (ret == null) {
			try {// 查找属性定义
				Class clz = null;
				if (property.getWriteMethod() != null)
					clz = property.getWriteMethod().getDeclaringClass();
				else if (property.getReadMethod() != null)
					clz = property.getReadMethod().getDeclaringClass();
				if (clz != null) {
					java.lang.reflect.Field field = clz
							.getDeclaredField(property.getName());
					ret = field.getAnnotation(annotationClass);
				}
			} catch (java.lang.NoSuchFieldException e) {

			}
		}
		return ret;
	}

	public void po2form(Object obj, Map map) {
		if (map == null)
			map = new java.util.HashMap();
		if(obj instanceof Map)
		{
			Map data=(Map)obj;
			java.util.Iterator it=((Map)obj).entrySet().iterator();
			while(it.hasNext())
			{
				Map.Entry en=(Map.Entry )it.next();
				map.put(en.getKey(),en.getValue());
			}
		}
		else{
		BeanWrapper wrapper = new BeanWrapper(obj);
		PropertyDescriptor descriptors[] = wrapper.getPropertyDescriptors();
		for (int i = 0; i < descriptors.length; i++) {
			if (checkPoReadEnabled(obj, descriptors[i])) {
				String name = descriptors[i].getName();
				try {
					if (descriptors[i].getReadMethod() != null) {
						map.put(name, wrapper.getPropertyValue(name));
					}
				} catch (Exception e) {
					logger.error("把PO中的对象转换成到form中出错!" + e);
					e.printStackTrace();
				}
			}
		}
		}
	}

	public Map parseForm2Obj(Map map, Object obj, boolean ignoreBlankString) {
		Map ret = new HashMap();
		if (validateManager == null)
			validateManager = FrameworkEngine.findValidatorManager();
		Map gOverrs = new java.util.HashMap();
		Overrides ovs = obj.getClass().getAnnotation(Overrides.class);
		if (ovs != null) {
			for (int j = 0; j < ovs.value().length; j++) {
				OverrideProperty op = ovs.value()[j];
				gOverrs.put(op.name(), op.newName());
			}
		}
		BeanWrapper wrapper = new BeanWrapper(obj);
		java.beans.PropertyDescriptor[] propertys = wrapper
				.getPropertyDescriptors();
		for (int i = 0; i < propertys.length; i++) {
			String name = propertys[i].getName();
			if (!wrapper.isWritableProperty(name))
				continue;
			Object propertyValue = null;
			/**
			 * 在属性值转换处理完成后，执行验证操作
			 */
			TargetObject validateObject = validateManager
					.findValidateObject(propertys[i]);
			//System.out.println(validateObject);
			/**
			 * 对标签进行处理，检测是否需要加载关联对象，以及是否有内嵌属性,根据字段进行处理。
			 */
			POLoad loader = null;
			MultiPOLoad mLoader = null;
			InnerProperty innerProperty = null;
			OverrideProperty ops = null;
			boolean enableInject = checkPoWriteEnabled(obj, propertys[i]);// 检测该属性是否允许自动注入
			if (!enableInject)
				continue;
			Map overrs = new java.util.HashMap(gOverrs);
			// 首先通过属性的写方法（设值方法)判断标签
			loader = propertys[i].getWriteMethod().getAnnotation(POLoad.class);
			mLoader = propertys[i].getWriteMethod().getAnnotation(MultiPOLoad.class);
			innerProperty = propertys[i].getWriteMethod().getAnnotation(
					InnerProperty.class);
			ops = propertys[i].getWriteMethod().getAnnotation(
					OverrideProperty.class);
			// 如果在设置方法上没有使用任何设置标签，则进一步通过属性定义名称上的标签来判断属性
			try {
				java.lang.reflect.Field f = propertys[i].getWriteMethod()
						.getDeclaringClass().getDeclaredField(name);
				if (loader == null)
					loader = f.getAnnotation(POLoad.class);
				if(mLoader == null){