Java自动化测试中多数据源的切换(实例讲解)

在做自动化测试时，数据驱动是一个很重要的概念，当数据与脚本分离后，面对茫茫多的数据，管理数据又成了一个大问题，而数据源又可能面对多个，就跟在开发过程中，有时候要连接mysql，有时候又要连接sql server一样，如何做到快速切换？下面的示例中，我们将从一个数据源开始，一步步的演示下去：

一. 用外部文件做数据驱动的基本写法

1.1　我们在做数据驱动时，把数据存储在java的属性文件中：data.properties

username=test
password=123456

1.2　解析properties文件

public class propertieshandler {
 
 private static properties loadpropertiesfile(string filepath){
  properties p = new properties();
  inputstream in = null;
  try {
   in = new fileinputstream(new file(filepath));
   p.load(in);
  } catch (filenotfoundexception e) {
   e.printstacktrace();
  } catch (ioexception e) {
   e.printstacktrace();
  }finally{
   try {
    if(in != null){
     in.close();
    }
   } catch (ioexception e) {
    e.printstacktrace();
   }
  }
  return p;
 }
  
 /**
  * 将property转换成map
  * @param key
  * @return
  */
 @suppresswarnings({ "rawtypes", "unchecked" })
 public static map<string, string> getpropertydata(string filepath){
  try{
   return new hashmap<string, string>((map)propertieshandler.loadpropertiesfile(filepath));
  }catch(exception e){
   e.printstacktrace();
  }
  return new hashmap<string, string>();
 }
  
 public static void main(string[] args) {
  system.out.println(propertieshandler.getpropertydata("file/data.properties"));
 }
}

1.3　写一个testbase类，里面用来存放testng的dataprovider

public class testbase {
  
 @dataprovider
 public object[][] dataprovider(){
  return this.gettestdata();
 }
  
 private object[][] gettestdata(){
  propertiesdata testdata = new propertiesdata();
  list<map<string, string>> listdata = testdata.gettestmethoddata();
  object[][] object = new object[listdata.size()][];
  for (int i = 0; i < listdata.size(); i++) {
   object[i] = new object[]{listdata.get(i)};
  }
  return object;
 }
  
}

可以看出，我只要有一个类，能够提供出一个数据类型为：list<map<string, string>>的数据对象，就能够转换成object[][]的二维数组，就能够提供给测试方法运行了。

1.4　在1.3中出现了一个propertiesdata类，现在来实现这个类

public class propertiesdata {
  
 public list<map<string, string>> gettestmethoddata(){
  list<map<string, string>> list = new arraylist<map<string, string>>();
  list.add(propertieshandler.getpropertydata("file/data.properties"));
  return list;
 }
  
}

1.5　以上中有数据解析类，有数据加载类，有数据提供的基础类，于是我们再结合测试方法，把这三个基础类给融合在一起，就形成了一个外部文件来做数据源的完整示例了：

public class testdemo extends testbase{
  
 @test(dataprovider="dataprovider")
 public void testdemo(map<string, string> param){
  system.out.println(param.get("username"));
  system.out.println(param.get("password"));
 }
  
}

二.　属性文件换成txt文件的实现

2.1　如果有多个数据源，我想用txt来存放数据，txt里面存放一个json串：data.txt

{
 "username":"test",
 "password":"123456"
}

2.2　读出这个txt文件

public class fileutils {
 
 public static string readfile(string filename) {
  inputstream is = null;
  stringbuffer sb = new stringbuffer();
  try {
   is = new fileinputstream(filename);
   byte[] bytebuffer = new byte[is.available()];
   int read = 0;
   while((read = is.read(bytebuffer)) != -1){
    sb.append(new string(bytebuffer, 0, read));
   }
  } catch (filenotfoundexception e) {
   e.printstacktrace();
  } catch (ioexception e) {
   e.printstacktrace();
  }finally{
   try {
    if(is!=null){
     is.close();
    }
   } catch (ioexception e) {
    e.printstacktrace();
   }
  }
  return sb.tostring();
 }
  
 public static void main(string[] args) {
  system.out.println(fileutils.readfile("file/data.txt"));
 }
  
}

2.3　将读取出来的json串进行解析(这里需要用到一个jar包，gson.jar)

public class txtdata {
  
 public list<map<string, string>> gettestmethoddata(){
  list<map<string, string>> list = new arraylist<map<string, string>>();
  string data = fileutils.readfile("file/data.txt");
  gson gson = new gson();
  map<string, string> datamap = gson.fromjson(data, new typetoken<map<string, string>>(){}.gettype());
  list.add(datamap);
  return list;
 }
  
}

2.4　将txtdata类给用上，即将testbase类里的用到propertiesdata类的地方换成txtdata类即可

private object[][] gettestdata(){
 txtdata testdata = new txtdata();
 list<map<string, string>> listdata = testdata.gettestmethoddata();
 object[][] object = new object[listdata.size()][];
 for (int i = 0; i < listdata.size(); i++) {
  object[i] = new object[]{listdata.get(i)};
 }
 return object;
}

2.5　运行testdemo测试类后，发现结果与之前用propertiesdata类出现的结果一模一样。

三.　用接口来实现

3.1　上面的两种数据源，在把数据源里的内容给加载出来且加载出来的数据类型为：list<map<string, string>>后，只需要把testbase类里的数据源加载类给替换一个即可，那如此一来，我们可以利用java里面的interface来重构我们的代码，首先当然得要有一个interface

public interface datainterface {
 public list<map<string, string>> gettestmethoddata();
}

3.2　我们的propertiesdata类与txtdata类当然要实现这个接口了

public class propertiesdata implements datainterface{
  
 public list<map<string, string>> gettestmethoddata(){
  list<map<string, string>> list = new arraylist<map<string, string>>();
  list.add(propertieshandler.getpropertydata("file/data.properties"));
  return list;
 }
  
}

public class txtdata implements datainterface{
  
 public list<map<string, string>> gettestmethoddata(){
  list<map<string, string>> list = new arraylist<map<string, string>>();
  string data = fileutils.readfile("file/data.txt");
  gson gson = new gson();
  map<string, string> datamap = gson.fromjson(data, new typetoken<map<string, string>>(){}.gettype());
  list.add(datamap);
  return list;
 }
  
}

3.3　然后在testbase里就要有所改变了，即产生数据加载的类对象要发生改变，我们在testbase里新加一个方法(这是产生类对象的一种新的方式)

private datainterface getdatainstance(string key){
 datainterface data = null;
 try {
  data = (datainterface) class.forname(key).newinstance();
 } catch (instantiationexception | illegalaccessexception | classnotfoundexception e) {
  e.printstacktrace();
 }
 return data;
}

3.4　testbase类里的gettestdata()方法就要重新的改变一下了

private object[][] gettestdata(){
 datainterface testdata = this.getdatainstance("com.test.testdata.propertiesdata");
 list<map<string, string>> listdata = testdata.gettestmethoddata();
 object[][] object = new object[listdata.size()][];
 for (int i = 0; i < listdata.size(); i++) {
  object[i] = new object[]{listdata.get(i)};
 }
 return object;
}

private object[][] gettestdata(){
 datainterface testdata = this.getdatainstance("com.test.testdata.txtdata");
 list<map<string, string>> listdata = testdata.gettestmethoddata();
 object[][] object = new object[listdata.size()][];
 for (int i = 0; i < listdata.size(); i++) {
  object[i] = new object[]{listdata.get(i)};
 }
 return object;
}

3.5　再次运行testdemo，即可发现结果仍然是一样的。所以，这时候只需要改变数据加载类的路径即可了。

四.　将数据加载类的路径可配置化

4.1　这时候，我们就可以想着把数据加载类的路径写在配置文件中了config.properties

datasource=com.test.testdata.txtdata

4.2　加载config文件

public class config {
  
 public static string data_source;
  
 static{
  map<string, string> map = propertieshandler.getpropertydata("config/config.properties");
  data_source = map.get("datasource");
 }
  
}

4.3　将testbase里的gettestdata()方法再改进一下：

private object[][] gettestdata(){
 datainterface testdata = this.getdatainstance(config.data_source);
 list<map<string, string>> listdata = testdata.gettestmethoddata();
 object[][] object = new object[listdata.size()][];
 for (int i = 0; i < listdata.size(); i++) {
  object[i] = new object[]{listdata.get(i)};
 }
 return object;
}

4.4　再次运行testdemo类，结果仍然是一样的。到此为止，我们已实现了去更改配置文件里面的内容，来选择加载数据源。

五.　多数据源的切换

5.1　如果一个测试类里有两个测试方法，那么在配置文件里配置好数据源后，就表示这两个测试方法都将会加载同样的数据源，但如果我们希望一个测试方法用属性文件的数据源，另一个方法用txt的数据源，这个如何办？也就是需要实现在全局配置化后，局部可再次选择数据源。我将会利用到java里的注解，来实现。所以我们先定义一个datasource的注解

@target(elementtype.field)
@retention(retentionpolicy.runtime)
public @interface datasource {
 string value();
}

5.2　解析该注解

public class datasources {
  
 public static string getdatasource(method method){
  datasource ds = method.getannotation(datasource.class);
  if(ds != null){
   return ds.value();
  }
  return null;
 }
  
}

5.3　该注解的使用

@datasource("com.test.testdata.propertiesdata")
@test(dataprovider="dataprovider")
public void testdemo(map<string, string> param){
 system.out.println(param.get("username"));
 system.out.println(param.get("password"));
}

5.4　testbase类里的gettestdata()方法再次的更改，要利用上这个注解解析出来的值

private object[][] gettestdata(method method){
 string sourcekey = datasources.getdatasource(method);
 if(sourcekey==null){
  sourcekey = config.data_source;
 }
 datainterface testdata = this.getdatainstance(sourcekey);
 list<map<string, string>> listdata = testdata.gettestmethoddata();
 object[][] object = new object[listdata.size()][];
 for (int i = 0; i < listdata.size(); i++) {
  object[i] = new object[]{listdata.get(i)};
 }
 return object;
}

这段代码可以看到，如果测试方法标注datasource,则会以标注的注解值为准，否则则会以全局配置的值为准。

5.5　在testdemo里多加一个测试方法，以示区别

public class testdemo extends testbase{
  
 @datasource("com.test.testdata.propertiesdata")
 @test(dataprovider="dataprovider")
 public void testdemo(map<string, string> param){
  system.out.println(param.get("username"));
  system.out.println(param.get("password"));
 }
  
 @test(dataprovider="dataprovider")
 public void testdemo1(map<string, string> param){
  system.out.println(param.get("username"));
  system.out.println(param.get("password"));
 }
  
}

上面的测试类中，两个测试方法，一个用了全局的配置数据源值，一个用了注解数据源值。大家可以运行的看看结果。

六.　工程结构图：

以上这篇java自动化测试中多数据源的切换(实例讲解)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。