javatypes.java

TestDataBuilder是一个采用Java编写的

package com.testDataBuilder.core.baseType;

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.sql.Date;
import java.text.NumberFormat;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.filefilter.SuffixFileFilter;
import org.apache.commons.lang.RandomStringUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import com.testDataBuilder.core.role.Role;
import com.testDataBuilder.exception.BaseException;
import com.testDataBuilder.util.Global;

/**
 * java类型.
 * <p>Title：JavaType.java</p>
 * <p>Description：TestDataBuilder</p>
 * <p>Copyright：Copyright (c)2007 TestDataBuilder,Inc</p>
 * <p>Company：TestDataBuilder,Inc</p> 
 * @author LiuXiaojie 2007-6-11
 * @version 1.0
 */
public class JavaTypes {

    static Logger logger = Logger.getLogger(JavaTypes.class);
    
    private JavaTypes(){
        
    }
    
    private static JavaTypes instance;
    
    public static JavaTypes getInstance(){
        if(instance == null){
            instance = new JavaTypes();
        }
        return instance;
    }
    
    public Class loadTypeClass(String className) throws ClassNotFoundException, MalformedURLException{
        if(urlClassLoader == null){
            File dir = new File(path);
            URL[] urls = new URL[1];
            if(dir.exists()){   
               urls[0] =dir.toURL();
            }
            urlClassLoader = new URLClassLoader(urls,Role.class.getClassLoader());
        }        
        
        return urlClassLoader.loadClass(className);
    }
    
    URLClassLoader urlClassLoader = null;
    String path = null;
    
    public static final String TYPE_CONFIG_FILE_SUFFIX = ".type.txt";
    public static final FilenameFilter typeConfigFilter 
                    = new SuffixFileFilter(TYPE_CONFIG_FILE_SUFFIX); 
    
    public boolean init(String path){
        this.path = path;        
        File dir = new File(path);
        logger.info(String.format("从目录%s下加载怎定义类型信息.", dir.getAbsolutePath()));
        if(dir.exists()){
            File[] typeConfigFiles = dir.listFiles(typeConfigFilter);
            for(File typeConfigFile : typeConfigFiles){
                try {
                    String configs = FileUtils.readFileToString(typeConfigFile, "utf-8");
                    String[] classNames = configs.split(";");
                    for(String className : classNames){
                        if(StringUtils.isNotEmpty(className)){
                            className = className.trim();
                            
                            try{
                                Class clazz = this.loadTypeClass(className);
                                IType type = (IType)clazz.newInstance();                            
                                type.init(path);
                                this.addType(type);
                            }catch(BaseException ex){
                                logger.error("initialization new type[" + className +  "] error", ex);
                            }  catch (ClassNotFoundException ex) {
                                logger.error("configuration file[" + typeConfigFile.getAbsolutePath() 
                                        + "] type[" +  className + "]not exist。or class file not in classpath。" 
                                        , ex);
                            } catch (InstantiationException ex) {
                                logger.error("JavaTypes", ex);
                            } catch (IllegalAccessException ex) {
                                logger.error("JavaTypes", ex);
                            }
                        }
                    }
                } catch (IOException e) {
                    logger.error("JavaTypes", e);
                }
            }
        }else{
            logger.info(String.format("目录[%s]不存在", dir.getAbsolutePath()));
        }
        return true;
    }
    //[start]常量字段。
    public static final Class BOOLEAN = Boolean.class;
    
    public static final Class BYTE = Byte.class;
    
    public static final Class DOUBLE = Double.class;
    
    public static final Class FLOAT = Float.class;
    
    public static final Class INT = Integer.class;
    
    public static final Class LONG = Long.class;
    
    public static final Class OBJECT = Object.class;
    
    public static final Class STRING = String.class;
    
    public static final Class SHORT = Short.class;
    
    public static final Class DATE = Date.class;
    //[end]
//    public static final String IP = "ip";
    
    private Map<Class,IType> addedTypes = null;
    
    public Map<Class, IType> getAddedTypes(){
        if(addedTypes == null){
            addedTypes = new HashMap<Class,IType>();
        }
        return addedTypes;
    }

    
    public IType addType(IType type){
        return getAddedTypes().put(type.getClass(), type);
    }
    
    public IType getAddedType(Class clazz){
        IType itype = getAddedTypes().get(clazz);
        if(itype == null){
            logger.error("type [" + clazz + "] not exits!");
        }
        return itype; 
    }

    private List<Class> typeList = null;
    
        
    public List<Class> getAllTypes(){
        if(typeList == null){
            typeList = new LinkedList<Class>();
            typeList.add(BOOLEAN);
            typeList.add(BYTE);
            typeList.add(DOUBLE);
            typeList.add(FLOAT);
            typeList.add(INT);
            typeList.add(LONG);
            typeList.add(OBJECT);
            typeList.add(STRING);
            typeList.add(SHORT);
            typeList.add(DATE);
            Map<Class, IType> addedTypeMap = getAddedTypes();
            if(addedTypeMap != null){
                for(IType type : addedTypeMap.values()){
                    typeList.add(type.getClass());
                }
            }
        }        
        return typeList;
    }
    
    /**
     * 得到一个数据类型的最小值.
     * <p><code>getMin</code></p>
     * @param javaType
     * @return
     * @author LiuXiaojie 2007-6-11
     */
    public double getMin(Class javaType, int size, int decimalDigits){
        double min = 0;
        if(javaType != null){
            if(javaType.equals(STRING)){
                min = 0;
            }else if(javaType.equals(BYTE)){
                min = Byte.MIN_VALUE;
            }else if(javaType.equals(DOUBLE)){
                if(size == 0 && decimalDigits == 0){
                    min = Double.MIN_VALUE;
                }else{
                    int m = size - decimalDigits + 1;
                    min = -1 * (Math.pow(10, m) - 1);
                }
            }else if(javaType.equals(FLOAT)){
                min = Float.MIN_VALUE;
            }else if(javaType.equals(INT)){
                min = Integer.MIN_VALUE;
            }else if(javaType.equals(LONG)){
                min = Long.MIN_VALUE;
            }else if(javaType.equals(SHORT)){
                min = Short.MIN_VALUE;
            }else if(javaType.equals(DATE)){
                min = java.sql.Date.valueOf("0-1-1").getTime();
            }else if(javaType.equals(BOOLEAN)){
                min = 0;
            }else if(javaType.equals(OBJECT)){
                min = 0;
            }else if(IType.class.isAssignableFrom(javaType)){
                IType type = this.getAddedType(javaType);
                min = type.getMin(); 
            }else{
                logger.error("JavaTypes, unknow type:" + javaType.getName());
            }
        }
        return min;
    }