目前行业内测试框架仅有两种实现形式：

关键字驱动+数据驱动
POM+数据驱动

关键字驱动：

Postman（接口测试）可以通过选择get/post来实现一个method的方法

就是做了一个函数的封装，当选择为Get时，调用Get函数，选择为Post时，调用Post函数。

项目A：

抵代更新快，版本交替频繁，所谓的敏捷开发

项目B:

当一个很长的系统
关键字驱动如何实现：

1、结构设计

1）分层：

在所有的测试框架中，要将代码与数据分层，要将逻辑代码与测试代码分离。
2、结合业务：在任何一个测试的行为，都是介于业务来实现的。
3、为什么要走框架：1）企业需要的人，是积累

2）便于维护和升级

3）便于执行的效率

4、代码的实现

1）代码的分层：

1. 逻辑层

2. 测试层

3. 数据层
数据驱动：

在实际的测试中，会准备大量的测试数据，用大量的数据进行测试；在自动化领域中，所有的内容都是基于编程去实现的，将代码与数据进行分离，单纯由数据组成文件，再由文件来驱动关键字，最终实现整个自动化的流程。

规范化的测试框架的研发结构标准：

在实际测试框架研发中心，一定要有分层处理，数据驱动也就是所谓的代码与测试数据的分离
关键字驱动+数据驱动：自动化测试框架的设计模式：

读取到数据，基于固定格式的数据内容进行拼接，拼接后的内容作为关键字所需要的参数，进行传入，从而执行对应的关键字，再将结果与预期进行对比，从而获得单条测试用例执行是否通过的结果。

本文是根据吴晓华编著的《Selenium WebDriver 实战宝典》的16.3节：关键字框架搭建及实战。 放在这里是为了以后有需要的时候，能够快速的搭建关键字驱动自动化框架。 实现功能：成功登录qq邮箱，点击“写信”，给好友发送邮件。关键字驱动的实现原理就是利用了java的反射机制
P.S如果我写的不太清楚，建议购买吴晓华编著的《Selenium WebDriver 实战宝典》一书
step1：创建项目
step2：4个工具类的封装具体参见如下步骤
(1)日志类Log.java及对应的配置文件log.xml
(2)模拟键盘操作类KeyBoardUtil.java
(3)元素定位类的ObjectMap.java
(4)等待工具类WaitUtil.java以及会使用到的元素表达式配置文件objectMap.properties
(5)Excel表格的读写操作ExcelUtil.java
(6)关键字需要的Excel文件,两个sheet：发送邮件；测试用例集合
其中发送邮件的表头字段：测试用例序号、测试步骤序号、测试步骤描述、关键字、操作元素的定位表达式、
操作值、测试结果
测试用例集合表单的内容如下
step3：针对上述表格的关键字，新建实现类KeyWordsAction.java
常量类Constant.java
step4:新建测试类TestSuiteByExcel,java
step5:运行结果：用例集合有2个testcase，发送邮件和登录qq邮箱，所以浏览器是打开关闭各两次
软件测试技术交流群：1125760266

龙源期刊网
http://www.qikan.com.cn
基于关键字驱动的
Web
自动化测试的研究
作者：朱宏峰
来源：《硅谷》
2009
年第
24
期
[
摘要
]
研究与设计以
Selenium
测试工具为基础
,
运用关键字驱动技术
,web
应用的自动化测
试框架。
[
关键词
]
关键字驱动
WebSelenium
中图分类号
:TP3
文献标识码
:A
文章编号
:1671-7597(2009)1220051-01
一、自动化测试技术概述
(
一
)Web
测试概述。随着互联网和
Web
技术的进步
,Web
应用频繁出现在人们工作生活
中。作为用户
,
优秀的
Web
应用为工作与生活带来了很多便利与快乐。作为软件开发测试人
员
,Web
应用系统的测试、确认和验收是一项重要而富有挑战性的工作。
Web
的系统测试与传
统的软件测试不同
,
它不但需要检查和验证是否按照设计的要求运行
,
而且还要测试系统在不同
用户的浏览器端的显示是否合适。重要的是
,
还要从最终用户的角度进行安全性和可用性测
试。
(
二
)
自动化测试技术的发展。软件自动化测试技术的发展一般分为
3
代
:
第一代
:
录制和回放。由测试工具记录你所做的每一步操作
,
加以录制并回放出来。测试工
具起到了一个录像机的作用
,
虽然操作异常简单
,
并且可以达到自动化测试的基本要求
,
但是缺少
灵活性
,
自身没有判断能力
,
容易记录一些无用操作
,
并且维护费用比较高
,
一旦界面改变
,
脚本就
将重新制作。
第二代
:
数据驱动。从专有的数据文件中读取数据
,
并将这些测试数据放入测试脚本中
,
不同
的数据文件对应不同的测试用例。和第一代相比
,
提高了脚本的利用率
,
但是同样受到被测软件
界面变化的影响。
第三代
:
关键字驱动。关键字驱动测试是数据驱动测试的一种改进类型
,
它将测试逻辑按照
关键字进行分解
,
形成数据文件
,
关键字对应封装的业务逻辑。主要关键字包括三类
:
被操作对象
(Item)
、操作
(OperatiOn)
和值
(value),
用面向对象形式可将其表现为
Item.operation(value)
。

自动化测试现在越来越趋向于平台化，平台化是致力于协同工作，提高效率，让更多人参与自动化的一个过程，在我看来，平台化中，有一个更为关键点，就是关键字驱动，只有把自动化测试的代码转换成为大家更容易懂的自然语言，才能让更多不懂代码的人加入进去，才能达到平台化的目的。今天我们就来谈谈自动化测试中关键字驱动的原理及实现方式。
先来看一个例子，老师对着同学们说了一句：去把桌子从A地点搬到B地点。当老师发出这个命令后，发现没有人动，因为没有明确的对象，不知道这个命令是对谁发出的，于是老师再说了一句：张三，去把桌子从A地点搬到B地点。这时候，有了明确的对象--张三，有了命令的主体--搬桌子从A到B。所以这句” 张三，去把桌子从A地点搬到B地点”中就有两个关键字：张三、把桌子从A地点搬到B地点。当这两个关键字缺少任何一个，这件事就不可能完成。所以，我们可以把这个场景理解为关键字驱动，假如我们把上面这句话转换为代码：
public class MoveDesk {
private Person zhangsan;
public void setZhangsan(Person zhangsan) {
this.zhangsan = zhangsan;
}
public void moveDeskFromA2B(){
zhangsan.getTheCommandFromTeacher();
zhangsan.findTheDeskAtA();
zhangsan.moveDeskToB();
zhangsan.notifyTeacherHadFinished();
}
public static void main(String[] args) {
MoveDesk md = new MoveDesk();
md.setZhangsan("张三");
md.moveDeskFromA2B();
}
}
上面的代码当然是伪代码，但从中可以看出，其为了达到一个目的，流程都是一样的，那两个关键字在main方法中体现为：张三对应md.setZhangsan("张三")，”把桌子从A地点搬到B地点”对应md.moveDeskFromA2B()。由此我们可以这样理解一下：每一个关键字对应一个具体的方法。所以，总结一下关键字驱动的实现特点：
1. 每一个关键字对应的方法(以下称为关键方法)必须能够随时被调用，这就像老师对张三发出的命令张三必须去执行一样。在JAVA里面为了达到这个关键方法随时能被调用，其类对象必须事先就被new好，所以要有一个对象池，这个对象池就像一个班级，有很多个学生可以供老师发出命令并去执行。
2. 关键字必须与关键方法进行关联，就像老师让张三搬桌子，而张三跑去买了一包烟，这就不对了，所以，必须要有一个关键字与关键方法的映射表。
3. 得有一个关键字的解析方式，比如上面那条命令中，我们要能够得出张三、把桌子从A地点搬到B地点这两个关键字，要是不能得出关键字，关键方法就会少执行，就如上面的伪代码中，如果去掉md.setZhangsan("张三")这一句，显然就会报空指针异常了。
4. 上面这三条具备后，就是执行了，老师发出的命令，张三要能够执行，当然，要是张三是个刺头就另说了。JAVA代码能够交给JVM去执行，但转换成为关键字后，JVM就不认识这些关键字了，所以，我们也必须要有一个健壮的执行引擎，让“张三，去把桌子从A地点搬到B地点”这一句话能够被执行成功。
综上所述，只要我们把上面的四条通过代码来实现，一个简单的关键字框架雏形就出来了，接下来我们一条条的实现。
1.对象池：
public class RegisterCenter {
public static Map OBJ_POOLS = new HashMap();
static{
OBJ_POOLS.put(MoveDesk.class.getName(), new MoveDesk());
}
}
将所有含有关键方法的类都初始化一遍，然后放到OBJ_POOLS这个对象里，方面后面直接调用关键方法。(请大家试着用注解去实现，会更炫)
2.映射表：
public class KeywordReflect {
public static Map> KEYWORD_POOLS = new HashMap>();
static{
KEYWORD_POOLS.put("张三", KeywordReflect.methodInfo(MoveDesk.class.getName(), "setZhangsan"));
KEYWORD_POOLS.put("把桌子从A地点搬到B地点", KeywordReflect.methodInfo(MoveDesk.class.getName(), "moveDeskFromA2B"));
}
public static Map methodInfo(String className, String methodName){
Map methodInfo = new HashMap();
methodInfo.put("class", className);
methodInfo.put("method", methodName);
return methodInfo;
}
}
说明：上面的KEYWORD_POOLS对象的数据结构是MAP里面套了一个MAP，这是因为要明确类对象，因为不同的类里可能有相同名称的方法，所以，为了避免混乱，必须标注好一个方法的类与方法名，这样才能建立好一一对应的映射表。(同样可以用注解来实现)
3.解析关键字
为了能够解析出关键字，我们得把” 张三，去把桌子从A地点搬到B地点”这句话的关键字给标注出来，改造一下”${张三}，去${把桌子从A地点搬到B地点}”,这样就把关键字给明确的标注出来了，虽然从直观感受上差了那么一点点，但却是关键字驱动中很重要的一部分。接下来的问题转变成为了对一段字符串中${}的解析了：
正则类：
public class RegExp {
public boolean match(String reg, String str) {
return Pattern.matches(reg, str);
}
public List find(String reg, String str) {
Matcher matcher = Pattern.compile(reg).matcher(str);
List list = new ArrayList();
while (matcher.find()) {
list.add(matcher.group());
}
return list;
}
}
获取关键字类：
public class ParseKeyword {
public List getKeywords(String p){
String reg = "(?<=(?
RegExp re = new RegExp();
List list = re.find(reg, p);
return list;
}
public static void main(String[] args) {
ParseKeyword p = new ParseKeyword();
System.out.println(p.getKeywords("a${a}a"));
System.out.println(p.getKeywords("a\\${a}a"));
System.out.println(p.getKeywords("a${a\\}a"));
System.out.println(p.getKeywords("a${a\\}a}a"));
System.out.println(p.getKeywords("a${a}a${"));
System.out.println(p.getKeywords("a${ab}a${a}"));
}
}
说明：里面用到了正则预查模式，正则预查模式是正则中的一种相对高阶的用法，掌握这个后，你的正则就会上一个台阶。
4. 执行引擎:
执行引擎先要找到需要执行的语句，所以，首先应该把老师发的那个命令给读取出来，这个命令可以存放在任何格式的文件里，只要能被读出来即可，在这里我们保存在command.txt里：
读取这个命令：
public class Executor {
public List readTxtFile(String filePath) {
List list = new ArrayList();
try {
String encoding = "UTF8";
File file = new File(filePath);
if (file.isFile() && file.exists()) {
InputStreamReader read = new InputStreamReader(new FileInputStream(file), encoding);
BufferedReader bufferedReader = new BufferedReader(read);
String lineTxt = null;
while ((lineTxt = bufferedReader.readLine()) != null) {
list.add(lineTxt);
}
read.close();
bufferedReader.close();
} else {
System.out.println("找不到指定的文件");
}
} catch (Exception e) {
System.out.println("读取文件内容出错");
e.printStackTrace();
}
return list;
}
public static void main(String[] args) {
Executor e = new Executor();
System.out.println(e.readTxtFile("src/command.txt"));
}
}
读取之后，流程就是：获取关键字->获取关键方法->执行关键方法.
public class Executor {
private ParseKeyword pk = new ParseKeyword();
public List readTxtFile(String filePath) {
List list = new ArrayList();
try {
String encoding = "UTF8";
File file = new File(filePath);
if (file.isFile() && file.exists()) {
InputStreamReader read = new InputStreamReader(new FileInputStream(file), encoding);
BufferedReader bufferedReader = new BufferedReader(read);
String lineTxt = null;
while ((lineTxt = bufferedReader.readLine()) != null) {
list.add(lineTxt);
}
read.close();
bufferedReader.close();
} else {
System.out.println("找不到指定的文件");
}
} catch (Exception e) {
System.out.println("读取文件内容出错");
e.printStackTrace();
}
return list;
}
public void executor(){
List commands = this.readTxtFile("src/command.txt");
for (String command : commands) {
List keywords = pk.getKeywords(command);
for (String keyword : keywords) {
this.invoke(keyword);
}
}
}
public void invoke(String keyword){
Map keyMethod = KeywordReflect.KEYWORD_POOLS.get(keyword);
String className = keyMethod.get("class");
String methodName = keyMethod.get("method");
Object obj = RegisterCenter.OBJ_POOLS.get(className);
Method method = this.getMethod(methodName, obj);
try {
method.invoke(obj);
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
e.printStackTrace();
}
}
private Method getMethod(String methodName, Object obj) {
try {
Method[] methods = obj.getClass().getMethods();
for (Method m : methods) {
if (m.getName().equals(methodName)) {
return m;
}
}
} catch (SecurityException e) {
return null;
}
return null;
}
public static void main(String[] args) {
Executor e = new Executor();
e.executor();
}
}
为了大家能够看到执行结果，把MoveDesk类给改改：
public class MoveDesk {
public void setZhangsan() {
System.out.println("this is zhangsan");
}
public void moveDeskFromA2B(){
System.out.println("this is test!");
}
}
这样执行之后，就能看到这两个关键方法体被执行了！执行引擎中最关键的就是利用了JAVA的反射来执行方法！
以上的代码经过测试运行通过！
由此一个最最简单的关键字驱动架子就搭建完成了，还有如下的一些点需要大家自行去完成：关键方法参数处理，关键方法返回值处理，异常处理，结合数据驱动，结合测试框架(TESTNG/JUNIT)等。也有很大的优化空间留给大家自行发挥去吧！