基于Java+HttpClient+TestNG的接口自动化测试框架（六）-------随机函数的处理

　　我们之前使用接口类及接口实现类的方式，来定义了我们使用的工具类。

　　而所有的工具类中，随机函数是比较难于处理的。因为随机的对象不明确，随机的个数不明确。我们可以使用定义随机类的方式，来简单而快速的处理我们的随机对象生成的需要。

　　首先，我们先定义一个randomUtil的类，在这个类中，我们可以将想生成的随机函数进行具体的定义。在此，我们举几个例子。比如，随机生成一个整数，随机生成一个定长（或不定长）的，带汉字（或不带汉字）的字符串，随机生成一个数组等等。

来看一下具体的RandomUtil类的代码：

import java.util.Random;

public class RandomUtil {
    //定义字母和数字
    public static String randomBase = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    public static String randomNumberBase = "0123456789";
    
    
    //Unicode 基本汉字编码范围0x4e00~0x9fa5 共 20902个，这个是从网上查到的。因此，我们要把这个随机的范围给计算出来。
    private final static int HANZI_LENGTH = 20902 ; 
    
    public static Random random = new Random();  
    
    /**
     * 随机生成一个汉字
     * @return
     */
    protected static char getRandomHanZi() {
        Random ran = new Random();
　　　　　//汉字编码从0x4e00开始到后面的20902之间
        return (char) (0x4e00 + ran.nextInt(HANZI_LENGTH));
    }
    
    /**
     * 随机生成一个字母
     * @return
     */
    protected static char getRandomStr() {
        Random ran = new Random();
        return (char) randomBase.charAt(ran.nextInt(62));
    }
    
    /**
     * 随机生成一个带有中文的字符串
     * @param length为字符串长度的参数
     * @return
     */
    public static String getRandomText(int length) {
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < length; i++) {
　　　　　　　//使用一个随机数字作为开关
            int randomNum = random.nextInt(2);
            char ch = 0 ;
            if (randomNum==0) {//生成汉字
                ch = getRandomHanZi();
            }else if (randomNum==1) {//生成数字或者字符
                ch = getRandomStr();
            }
            sb.append(String.valueOf(ch));
        }
        return sb.toString();
    }

　　   /**
　　   * 随机生成一个带有中文的字符串
　　   * @param length为字符串长度的参数，false为字符串，true为数字
　　   * @return
　　   */

public static String getRandom(int length, boolean onlyNumber) {
        String base;
        if (onlyNumber) {
            base = randomNumberBase;
        } else {
            base = randomBase;
        }
        
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < length; i++) {
            char chr;
            do {
                int number = random.nextInt(base.length());
                chr = base.charAt(number);
            } while (i==0&&chr=='0') ;//第一个字符不能为0,
            
            sb.append(chr);
        }
        return sb.toString();
    }

    
    public static String getRandomArr(int arrLength, int length, boolean flag) {
        StringBuffer sBuffer = new StringBuffer();
        for (int i = 0; i < arrLength; i++) {
            sBuffer.append(getRandom(length, flag)).append(",");
        }
        int leng = sBuffer.toString().length();
        return sBuffer.toString().substring(0, leng-1);
    }

    /**
     * 生成定长的字符串数组
     * @param arrLength  数组长度
     * @param paramStr   
     * @return
     */
    public static String generateStrArr(int arrLength, String paramStr) {
        StringBuffer sBuffer = new StringBuffer();
        for (int i = 0; i < arrLength; i++) {
            sBuffer.append(""").append(paramStr).append(""").append(",");
        }
        int leng = sBuffer.toString().length();
        return sBuffer.toString().substring(0, leng-1);
    }

}

　　在这个随机类中，我们定义了很多关于随机对象生成的方法，并确切定义了参数。于是，我们根据这个类，以及前面接口实现类定义的方法，可以快速的定义相关的随机函数。例如：

public class RandomFunction implements functionInterface {
    @Override
    public String execute(String[] args) {
        int len = args.length;
        int length = 6;// 默认为6
        boolean flag = false;// 默认为false
        if (len > 0) {// 第一个参数字符串长度
            length = Integer.valueOf(args[0]);
        }
        if (len > 1) {// 第二个参数是否纯字符串
            flag = Boolean.valueOf(args[1]);
        }
        return RandomUtil.getRandom(length, flag);
    }

    @Override
    public String getReferenceKey() {
        return "random";
    }

}

　　在这里，我们定义了该random函数。使用方法如下：

• __random(param1,param2):随机生成一个定长的字符串(不含中文)。param1:长度(非必填，默认为6)，param2：纯数字标识(非必填，默认为false)。

接下来，我们再继续第二个随机函数：

public class RandomStrArrFucntion implements functionInterface{

    @Override
    public String execute(String[] args) {
        // 第一个参数为数组长度 即生成参数个数
        // 第二个参数为参数长度
        // 第三个参数为是否只有数字标志
        int len = args.length;
        int arrLength = 1; // 默认数组长度为1
        int length = 6;// 默认参数长度为6
        boolean flag = false;// 默认为false
        if (len == 1) {
            arrLength = Integer.valueOf(args[0]);
        } else if (len == 2) {
            arrLength = Integer.valueOf(args[0]);
            length = Integer.valueOf(args[1]);
        } else if (len == 3) {
            arrLength = Integer.valueOf(args[0]);
            length = Integer.valueOf(args[1]);
            flag = Boolean.valueOf(args[1]);
        }
        return RandomUtil.getRandomArr(arrLength, length, flag);
    }

    @Override
    public String getReferenceKey() {
        // TODO Auto-generated method stub
        return "randomStrArr";
    }
}

　　在这里我们定义了随机生成字符串数组的的函数randomStrArr，使用形式如下：

• __randomStrArr(param1,param2,param3)：随机生成一个定长字符串数组。param1:数组长度(非必填，默认为1)，param2：单个字符串长度（非必填，默认6），param3：纯数字标识(非必填，默认为false)。

接下来，我们再看第三个随机函数：

public class RandomTextFunction implements functionInterface{

    @Override
    public String execute(String[] args) {
        int length = 6;// 默认为6
        if (StringUtil.isNotEmpty(args[0])) {
            length = Integer.valueOf(args[0]);// 参数是长度
        }
        return RandomUtil.getRandomText(length);
    }

    @Override
    public String getReferenceKey() {
        // TODO Auto-generated method stub
        return "randomText";
    }

}

　　在这里我们定义了第三个随机函数randomText，使用方式如下：

• __randomText(param1): 随机生成一个定长的字符串(含中文)。param1:长度(非必填，默认为6)

　　可以看到，我们再定义以上三个随机函数实现类的时候，都调用了RandomUtil里定义的方法。因此，如果我们在RandomUtil中定义了相关的方法后，用来生成随机函数，是非常快速和方便的。