tablemappingparse.java

EasyDBO是一个超轻量级对象-关系映射（Object/Relation Mapping

package com.easyjf.dbo;

import com.easyjf.util.JdkVersion;

import java.lang.reflect.Field;
import java.util.Collection;

import org.apache.log4j.Logger;

import com.easyjf.dbo.annotation.ManyToMany;
import com.easyjf.dbo.annotation.ManyToOne;
import com.easyjf.dbo.annotation.OneToOne;
import com.easyjf.dbo.annotation.Table;
import com.easyjf.dbo.annotation.TableField;
import com.easyjf.dbo.annotation.Transient;

/**
 * 这个类作为一个工具类，主要用来根据一定的策略来解析对象与关系表之间的映射关系，主要包括根据IObject接口解析、根据Java5的注解Annotation解析、根据对象的属性及表结构的对照自动解析等三种方式
 * 
 * @author 大峡
 * 
 */
abstract public class TableMappingParse {
	private final static Logger logger = Logger
			.getLogger(TableMappingParse.class);

	public static DBTable parseDomain(Class clz) {
		DBTable table = null;
		if (IObject.class.isAssignableFrom(clz)) {
			logger.info("通过使用IObject来解析对象及关系表映射关系！");
			table = parseByIObject(clz);
		} else if (JdkVersion.isAnnoatationSupport()) {
			logger.info("通过使用Java注解来解析对象及关系表映射关系！");
			table = parseByAnnotation(clz);
			//logger.info(table.getName());
		}
		return table;
	}

	// 通过接口定义Domain对象与关系表的映射
	public static DBTable parseByIObject(Class clz) {
		DBTable table = null;
		try {
			IObject tempObj = (IObject) clz.newInstance();
			table = new DBTable(tempObj.getTableName(), tempObj.getKeyField(),
					tempObj.getKeyGenerator());
			Field[] fields = clz.getDeclaredFields();
			for (int i = 0; i < fields.length; i++) {
				DBField field = new DBField();
				// System.out.println(fields[i].getName());
				field.setName(fields[i].getName());
				field.setType(fields[i].getType());
				table.addField(field.getName(), field);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return table;
	}

	/**
	 * 根据Java5的注解Annotation来解析对象及关系映射
	 * 
	 * @param clz
	 * @return
	 */
	public static DBTable parseByAnnotation(Class clz) {
		
		DBTable table = new DBTable();
		Table tableTag = (Table) clz.getAnnotation(Table.class);
		if (tableTag != null) {
			String tableName = tableTag.tableName();
			table.setName(tableName);
			table.setId(tableTag.keyField());
			table.setIdGenerator(tableTag.keyGenerator());				
		}		
			Field[] fields = clz.getDeclaredFields();			
			if (fields != null) {
				for (int i = 0; i < fields.length; i++) {					
					if (!fields[i].isAnnotationPresent(Transient.class)) {
						TableField tf = fields[i]
								.getAnnotation(TableField.class);
						boolean haveMapping = false;
						if (tf != null) {
							DBField field = new DBField();
							field.setName(tf.name());
							field.setType(fields[i].getType());
							field.setLazy(tf.lazy());
							table.addField(fields[i].getName(), field);
							haveMapping = true;
						}
						if (!haveMapping) {
							OneToOne one2one = fields[i]
									.getAnnotation(OneToOne.class);
							if (one2one != null) {
								OneToOneField field = new OneToOneField();
								field.setName(one2one.column());								
								field.setType(fields[i].getType());// one2one.type()
								field.setColumn(one2one.column());
								field.setLazy(one2one.lazy());
								field.setKey(one2one.key());
								field.setTableName(one2one.tableName());
								table.addClassField(fields[i].getName(), field);
								haveMapping = true;
							}
						}
						if (!haveMapping) {
							ManyToOne many2one = fields[i]
									.getAnnotation(ManyToOne.class);
							if (many2one != null) {
								ManyToOneField field = new ManyToOneField();
								field.setName(fields[i].getName());
								field.setType(many2one.type());
								field.setColumn(many2one.column());
								field.setLazy(many2one.lazy());
								field.setKey(many2one.key());
								field.setTableName(many2one.tableName());
								field.setFieldType(many2one.fieldType());
								table.addClassField(fields[i].getName(), field);
							}
						}
						if (!haveMapping) {
							ManyToMany many2many = fields[i]
									.getAnnotation(ManyToMany.class);
							if (many2many != null) {
								ManyToManyField field = new ManyToManyField();
								field.setName(fields[i].getName());
								field.setType(many2many.type());
								field.setColumn(many2many.column());
								field.setLazy(many2many.lazy());
								field.setKey(many2many.key());
								field.setTableName(many2many.tableName());
								field.setFieldType(many2many.fieldType());
								field.setTagColumn(many2many.tagColumn());
								field.setTagKey(many2many.tagKey());
								table.addClassField(fields[i].getName(), field);
							}
						}						
						//由于前面都没有正确映射，这里使用默认映射方式
						if(!haveMapping)
						{
							DBField field=getDefaultMappingByFieldAnnotation(fields[i]);
							if(field!=null){
							if(field instanceof ClassField)
								table.addClassField(fields[i].getName(),(ClassField)field);
							else table.addField(fields[i].getName(), field);
							}
						}					
					}
					else logger.debug("瞬间属性:"+fields[i].getName());
				}			
		}
		if(clz.getSuperclass()!=Object.class)table.concat(parseByAnnotation(clz.getSuperclass()));
		return table;
	}
	private static DBField getDefaultMappingByFieldAnnotation(java.lang.reflect.Field f)
	{
		 DBField field = new DBField();
		 field.setName(f.getName());
		 field.setType(f.getType());		
		 return Collection.class.isAssignableFrom(f.getType())?null:field;
	}
}