metadataloader.java

《j2ee开发全程实录》随书源码

package com.cownew.PIS.framework.common.metaDataMgr;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.jar.JarFile;

import org.apache.log4j.Logger;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;

import com.cownew.ctk.common.ExceptionUtils;
import com.cownew.ctk.io.ResourceUtils;

/**
 * 元数据加载器
 * @author 杨中科
 *
 */
public class MetaDataLoader implements IMetaDataLoader
{
	//实体路径到元数据模型的缓存
	private static Map pathEntityMap;

	//Vo类名到实体路径的缓存
	private static Map voClassPathEntityMap;

	//元数据的位置
	private File metaDataPathFile;

	//元数据缓存文件的位置
	private File entityCacheFile;

	//元数据枚举器
	private IMetaDataEnumerator metaDataScanner;

	//元数据缓存开关
	private boolean cacheEnable;

	/**
	 * 
	 * @param metaDataPath 元数据所在的路径
	 * @param entityCacheFile 元数据缓存文件位置
	 */
	public MetaDataLoader(String metaDataPath, String entityCacheFile)
	{
		super();
		metaDataPathFile = new File(metaDataPath);
		if (!metaDataPathFile.exists())
		{
			throw new IllegalArgumentException("path:" + metaDataPath
					+ " not found!");
		}

		//如果元数据所在的路径是目录,则目录元数据扫描器
		//否则使用Jar文件元数据扫描器
		if (metaDataPathFile.isDirectory())
		{
			metaDataScanner = new DirectoryMetaDataEnumerator(metaDataPathFile,
					"." + NameUtils.EMFEXT);
		} else
		{
			try
			{
				metaDataScanner = new JarFileMetaDataEnumerator(new JarFile(
						metaDataPathFile), "." + NameUtils.EMFEXT);
			} catch (IOException e)
			{
				throw ExceptionUtils.toRuntimeException(e);
			}
		}

		voClassPathEntityMap = new HashMap();
		this.entityCacheFile = new File(entityCacheFile);
		cacheEnable = false;
		loadMetaCache();
	}

	public void setCacheEnable(boolean cacheEnable)
	{
		this.cacheEnable = cacheEnable;
	}

	//从元数据缓存文件中加载缓存
	private void loadMetaCache()
	{
		if (!this.entityCacheFile.exists())
		{
			pathEntityMap = new HashMap();
		}

		ObjectInputStream ois = null;
		try
		{
			ois = new ObjectInputStream(new FileInputStream(
					this.entityCacheFile));
			pathEntityMap = (Map) ois.readObject();
		} catch (Exception e)
		{
			//只要发生异常就认为元数据缓存不可用,因此就不加载缓存
			//发生异常一般是由于类版本不一致造成的
			//这种异常一般只在开发环境或者正式运行环境的系统升级过程中出现
			pathEntityMap = null;
			Logger.getLogger(MetaDataLoader.class).error(e);
		} finally
		{
			ResourceUtils.close(ois);
		}

		if (pathEntityMap == null)
		{
			pathEntityMap = new HashMap();
		}
	}

	public EntityModelInfo loadEntityByEntityPath(String path)
	{

		// 只有元数据缓存打开的时候才从缓存中读取,这样就实现了开发环境的元数据热部署功能
		if (cacheEnable)
		{
			EntityModelInfo eInfo = (EntityModelInfo) pathEntityMap.get(path);
			if (eInfo != null)
			{
				return eInfo;
			}
		}

		InputStream inStream = null;
		try
		{
			//如果使用MetaDataLoader.class.getResourceAsStream()
			//就要去掉元数据路径前的"/"，不知为何
			inStream = getClass().getResourceAsStream(path);
			Document doc = new SAXReader().read(inStream);
			EntityModelInfo info = EntityMetaDataParser.xmlToBean(doc);
			pathEntityMap.put(path, info);
			return info;
		} catch (DocumentException e)
		{
			throw new MetaDataException(
					MetaDataException.LOADENTITYMETADATAERROR, e);
		} finally
		{
			ResourceUtils.close(inStream);
		}
	}

	public EntityModelInfo loadEntityByVOClass(Class voClass)
	{
		return loadEntityByVOClass(voClass.getName());
	}

	public EntityModelInfo loadEntityByVOClass(String voClass)
	{
		String entityPath = (String) voClassPathEntityMap.get(voClass);
		if (entityPath == null)
		{
			entityPath = NameUtils.getEntityPath(voClass);
			voClassPathEntityMap.put(voClass, entityPath);
		}
		EntityModelInfo info = loadEntityByEntityPath(entityPath);
		return info;
	}

	public List loadAllEntityPath()
	{
		return metaDataScanner.listAll();
	}

	//保存缓存
	public void saveCache()
	{
		ObjectOutputStream oos = null;
		try
		{
			//无论缓存文件是否存在,重新创建文件
			entityCacheFile.createNewFile();
			oos = new ObjectOutputStream(new FileOutputStream(entityCacheFile,
					false));
			oos.writeObject(pathEntityMap);
		} catch (Exception e)
		{
			Logger.getLogger(MetaDataLoader.class).error(e);
		} finally
		{
			ResourceUtils.close(oos);
		}
	}

}