entitymodelfilehandler.java

基于eclipse的工具开发代码

package com.cownew.studio.modelDev.common;

import java.io.InputStream;
import java.io.StringReader;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;

import com.cownew.studio.modelDev.common.enumdef.CascadeEnum;
import com.cownew.studio.modelDev.common.enumdef.DataTypeEnum;
import com.cownew.studio.modelDev.common.enumdef.LinkTypeEnum;
import com.cownew.studio.modelDev.common.enumdef.OuterJoinEnum;

public class EntityModelFileHandler
{
	private static String LINESEPARATOR = System.getProperty("line.separator");

	/**
	 * 得到实体定义模型的XML格式字符串
	 * 
	 * @param bean
	 * @return
	 */
	public static String modelToXML(EntityModelBean bean)
	{
		StringBuffer sb = new StringBuffer();
		sb.append("<EnityModel>").append(LINESEPARATOR);
		if (!CommonUtils.isEmptyString(bean.getName()))
		{
			sb.append("  <Name>").append(bean.getName())
				.append("</Name>")
				.append(LINESEPARATOR);
		}
		if (!CommonUtils.isEmptyString(bean.getAlias()))
		{
			sb.append("  <Alias>").append(bean.getAlias())
				.append("</Alias>")
				.append(LINESEPARATOR);
		}

		if (!CommonUtils.isEmptyString(bean.getPackageName()))
		{
			sb.append("  <PackageName>").append(bean.getPackageName())
				.append("</PackageName>").append(LINESEPARATOR);
		}

		if (!CommonUtils.isEmptyString(bean.getDbTableName()))
		{
			sb.append("  <DbTableName>").append(bean.getDbTableName())
				.append("</DbTableName>").append(LINESEPARATOR);
		}

		if (!CommonUtils.isEmptyString(bean.getPrimaryKey()))
		{
			sb.append("  <PrimaryKey>").append(bean.getPrimaryKey())
				.append("</PrimaryKey>").append(LINESEPARATOR);
		}

		// 拼装字段定义xml
		List<EntityFieldModelBean> fieldList = bean.getFieldList();
		if (fieldList != null && fieldList.size() > 0)
		{
			fillFieldListXML(sb, fieldList);
		}
		sb.append("</EnityModel>").append(LINESEPARATOR);
		return sb.toString();
	}

	private static void fillFieldListXML(StringBuffer sb, List<EntityFieldModelBean> fieldList)
	{
		sb.append("  <FieldList>").append(LINESEPARATOR);
		for (int i = 0, n = fieldList.size(); i < n; i++)
		{
			EntityFieldModelBean field = fieldList.get(i);
			sb.append("    <Field>").append(LINESEPARATOR);
			if (field.getName() != null)
			{
				sb.append("      <Name>").append(field.getName())
					.append("</Name>").append(LINESEPARATOR);
			}
			if (field.getAlias() != null)
			{
				sb.append("      <Alias>").append(field.getAlias())
					.append("</Alias>").append(LINESEPARATOR);
			}
			if (field.getDbFieldName() != null)
			{
				sb.append("      <DbFieldName>").append(
						field.getDbFieldName()).append("</DbFieldName>")
						.append(LINESEPARATOR);
			}
			DataTypeEnum dataType = field.getDataype();
			if (dataType != null)
			{
				sb.append("      <DataType>").append(dataType)
					.append("</DataType>").append(LINESEPARATOR);
			}

			sb.append("      <AllowNull>").append(field.isAllowNull())
					.append("</AllowNull>").append(LINESEPARATOR);

			if (dataType != null && dataType != DataTypeEnum.DATE
					&& dataType != DataTypeEnum.BOOLEAN)
			{
				sb.append("      <Length>").append(field.getLength())
						.append("</Length>").append(LINESEPARATOR);
			}

			if (dataType == DataTypeEnum.STRING)
			{
				sb.append(getLinkFieldXML(field));
			}

			sb.append("    </Field>").append(LINESEPARATOR);
		}
		sb.append("  </FieldList>").append(LINESEPARATOR);
	}

	/**
	 * 得到字段定义的xml字符串格式
	 * 
	 * @param field
	 * @return
	 */
	private static String getLinkFieldXML(EntityFieldModelBean field)
	{
		StringBuffer sb = new StringBuffer();
		sb.append("      <IsLinkProperty>").append(field.isLinkProperty())
				.append("</IsLinkProperty>").append(LINESEPARATOR);
		if (field.isLinkProperty() == false)
		{
			return sb.toString();
		}

		if (field.getLinkType() != null)
		{
			sb.append("      <LinkType>").append(field.getLinkType()).append(
					"</LinkType>").append(LINESEPARATOR);
		}

		if (field.getLinkEntity() != null)
		{
			sb.append("      <LinkEntity>").append(field.getLinkEntity())
					.append("</LinkEntity>").append(LINESEPARATOR);
		}

		if (field.getCascadeType() != null)
		{
			sb.append("      <CascadeType>").append(
					field.getCascadeType().toString()).append("</CascadeType>")
					.append(LINESEPARATOR);
		}

		sb.append("      <Constrained>").append(field.isConstrained())
			.append("</Constrained>").append(LINESEPARATOR);
		sb.append("      <Inverse>").append(field.isInverse())
			.append("</Inverse>").append(LINESEPARATOR);
		if (field.getKeyColumn() != null)
		{
			sb.append("      <KeyColumn>").append(field.getKeyColumn())
				.append("</KeyColumn>").append(LINESEPARATOR);
		}

		if (field.getOuterJoinType() != null)
		{
			sb.append("      <OuterJoinType>").append(field.getOuterJoinType())
					.append("</OuterJoinType>").append(LINESEPARATOR);
		}

		return sb.toString();
	}

	/**
	 * 将实体模型文件转换为实体定义的对象模型
	 * 
	 * @param doc
	 * @param project
	 * @return
	 */
	public static EntityModelBean xmlToBean(Document doc, IProject project)
	{
		EntityModelBean bean = new EntityModelBean();

		Node nameNode = doc.selectSingleNode("//EnityModel/Name");
		if (nameNode != null)
		{
			bean.setName(nameNode.getText());
		}

		Node aliasNode = doc.selectSingleNode("//EnityModel/Alias");
		if (aliasNode != null)
		{
			bean.setAlias(aliasNode.getText());
		}

		Node packageNameNode = doc.selectSingleNode("//EnityModel/PackageName");
		if (packageNameNode != null)
		{
			bean.setPackageName(packageNameNode.getText());
		}

		Node dbTableNameNode = doc.selectSingleNode("//EnityModel/DbTableName");
		if (dbTableNameNode != null)
		{
			bean.setDbTableName(dbTableNameNode.getText());
		}

		Node primaryKeyNode = doc.selectSingleNode("//EnityModel/PrimaryKey");
		if (primaryKeyNode != null)
		{
			bean.setPrimaryKey(primaryKeyNode.getText());
		}

		List<Node> fieldNodes = doc.selectNodes("//EnityModel/FieldList/Field");
		List<EntityFieldModelBean> fieldList = bean.getFieldList();
		for (int i = 0, n = fieldNodes.size(); i < n; i++)
		{
			fieldList.add(fieldNodeToBean(fieldNodes.get(i), project));
		}

		return bean;
	}

	/**
	 * 将实体模型文件转换为实体定义的对象模型
	 * 
	 * @param xmlStream
	 * @param project
	 * @return
	 * @throws DocumentException
	 */
	public static EntityModelBean xmlToBean(InputStream xmlStream,
			IProject project) throws DocumentException
	{
		Document doc = new SAXReader().read(xmlStream);
		return xmlToBean(doc, project);
	}

	/**
	 * 将实体模型文件转换为实体定义的对象模型
	 * 
	 * @param file
	 * @return
	 * @throws DocumentException
	 */
	public static EntityModelBean xmlToBean(IFile file)
			throws DocumentException
	{
		InputStream stream = null;
		try
		{
			stream = file.getContents();
			return xmlToBean(stream, file.getProject());
		} catch (CoreException e)
		{
			CommonUtils.handleExceptionAndAbort(e);
			return null;
		} finally
		{
			CommonUtils.closeStream(stream);
		}
	}

	/**
	 * 将实体模型文件转换为实体定义的对象模型
	 * 
	 * @param xml
	 * @param project
	 * @return
	 * @throws DocumentException
	 */
	public static EntityModelBean xmlToBean(String xml, IProject project)
			throws DocumentException
	{

		Document doc = new SAXReader().read(new StringReader(xml));
		return xmlToBean(doc, project);
	}

	/**
	 * 将xml文件中的字段节点解析为字段模型对象
	 * 
	 * @param fieldNode
	 * @param project
	 * @return
	 */
	private static EntityFieldModelBean fieldNodeToBean(Node fieldNode,
			IProject project)
	{
		EntityFieldModelBean bean = new EntityFieldModelBean(project);

		Node nameNode = fieldNode.selectSingleNode("Name");
		if (nameNode != null)
		{
			bean.setName(nameNode.getText());
		}

		Node aliasNode = fieldNode.selectSingleNode("Alias");
		if (aliasNode != null)
		{
			bean.setAlias(aliasNode.getText());
		}

		Node dbFieldNameNode = fieldNode.selectSingleNode("DbFieldName");
		if (dbFieldNameNode != null)
		{
			bean.setDbFieldName(dbFieldNameNode.getText());
		}

		Node fieldTypeNode = fieldNode.selectSingleNode("DataType");
		if (fieldTypeNode != null)
		{
			if (fieldTypeNode.getText() != null)
			{
				DataTypeEnum dataType = DataTypeEnum.valueOf(fieldTypeNode
						.getText());
				bean.setDataType(dataType);
			} else
			{
				bean.setDataType(DataTypeEnum.STRING);
			}

		}

		Node allowNullNode = fieldNode.selectSingleNode("AllowNull");
		if (allowNullNode != null)
		{
			String textAllowNull = allowNullNode.getText();
			boolean alloNull = Boolean.valueOf(textAllowNull).booleanValue();
			bean.setAllowNull(alloNull);
		}

		Node lengthNode = fieldNode.selectSingleNode("Length");
		if (lengthNode != null)
		{
			String textLength = lengthNode.getText();
			int length = Integer.valueOf(textLength).intValue();
			bean.setLength(length);
		}

		Node isLinkPropNode = fieldNode.selectSingleNode("IsLinkProperty");
		boolean isLinkProperty = false;
		if (isLinkPropNode != null)
		{
			String textIsLinkProp = isLinkPropNode.getText();

			isLinkProperty = Boolean.valueOf(textIsLinkProp).booleanValue();
			bean.setLinkProperty(isLinkProperty);
		}

		if (isLinkProperty)
		{
			parseLinkNode(fieldNode, bean);
		}

		return bean;
	}

	private static void parseLinkNode(Node fieldNode, EntityFieldModelBean bean)
	{
		Node linkTypeNode = fieldNode.selectSingleNode("LinkType");
		if (linkTypeNode != null)
		{
			String textLinkType = linkTypeNode.getText();
			if (textLinkType != null)
			{
				bean.setLinkType(LinkTypeEnum.valueOf(textLinkType));
			}
		}

		Node linkEntityNode = fieldNode.selectSingleNode("LinkEntity");
		if (linkEntityNode != null)
		{
			bean.setLinkEntity(linkEntityNode.getText());
		}

		Node cascadeTypeNode = fieldNode.selectSingleNode("CascadeType");
		if (cascadeTypeNode != null)
		{
			CascadeEnum cascadeType = CascadeEnum.valueOf(cascadeTypeNode.getText());
			bean.setCascadeType(cascadeType);
		}

		Node isConstrainedNode = fieldNode.selectSingleNode("Constrained");
		if (isConstrainedNode != null)
		{
			boolean isconstrained = Boolean.getBoolean(isConstrainedNode
					.getText());
			bean.setConstrained(isconstrained);
		}

		Node inverseNode = fieldNode.selectSingleNode("Inverse");
		if (inverseNode != null)
		{
			bean.setInverse(Boolean.getBoolean(inverseNode.getText()));
		}

		Node keyColumnNode = fieldNode.selectSingleNode("KeyColumn");
		if (keyColumnNode != null)
		{
			bean.setKeyColumn(keyColumnNode.getText());
		}

		Node outerJoinTypeNode = fieldNode.selectSingleNode("OuterJoinType");
		if (outerJoinTypeNode != null)
		{
			OuterJoinEnum outerJoinType = OuterJoinEnum.valueOf(outerJoinTypeNode
								.getText());
			bean.setOuterJoinType(outerJoinType);
		}
	}

}