理清楚逻辑：
1.想要使用该监听必须创建 class 实例化 IMethodInstance 接口（IMethodInstance 的父类是 ITestNGListener 接口）
2.重写该接口下面的方法
3.如图关系依赖：
4.再说一下上面的重点，这个方法返回的是一个 list 集合，调用类只执行 list 有的方法，如果没有即使用调用类方法用@Test方法标记也不执行
通过 IMethodInterceptor 监听器实现运行指定的组：
介绍一下 IMethodInterceptor：
先看一下这个接口源码返回什么类型：
/**
* This class is used to alter the list of test methods that TestNG is about to run.
*
* <p>
*
* An instance of this class will be invoked right before TestNG starts invoking test methods.
* Only methods that have no dependents and that don't depend on any other test methods will
* be passed in parameter. Implementers of this interface need to return a list of {@link IMethodInstance}
* that represents the list of test methods they want run. TestNG will run these methods in the
* same order found in the returned value.
*
* <p>
*
* Typically, the returned list will be just the methods passed in parameter but sorted
* differently, but it can actually have any size (it can be empty, it can be of the
* same size as the original list or it can contain more methods).
*
* <p>
*
* The {@link ITestContext} is passed in the <tt>intercept</tt> method so that implementers can set user values
* (using {@link ITestContext#setAttribute(String, Object)}), which they can then look up
* later while generating the reports.
*
* @author cbeust
*/
翻译源码（简单理一下）：
重点：
1.将在 TestNG 开始调用测试方法之前调用该类的实例（不同于上一个监听器，这个监听器是在调用测试方法之前开始调用这个监听器（上一个监听器是在调用测试方法的时候调用））
2.在参数中传递。这个接口的实现者需要返回{@link IMethodInstance}列表，表示要运行的测试方法列表（测列表返回的是所有实质性的方法，非测试方法也返回）
3.通常，返回的列表将只是在参数中传递的方法
用法：此处只写了根据 groupName 来运行，可扩展其他的
实战：
理清楚逻辑：
1.想要使用该监听必须创建 class 实例化 IMethodInstance 接口（IMethodInstance 的父类是 ITestNGListener 接口）
2.重写该接口下面的方法
3.如图关系依赖：
4.再说一下上面的重点，这个方法返回的是一个 list 集合，调用类只执行 list 有的方法，如果没有即使用调用类方法用@Test方法标记也不执行
代码块：主要为了实现功能减去了很多
监听类
/*
* 根据组名来运行
* ITestContext代理对象没有用到，这个接口可以取执行结果的信息，跟上一个监听器可以结合使用从而生成更完美的报告
* 我这里写出来的只是个人想写的
* */
//继承接口重写方法
public class ListenerTwo implements IMethodInterceptor {
List<IMethodInstance> returnMethod = new ArrayList<IMethodInstance>();
@Override
public List<IMethodInstance> intercept(List<IMethodInstance> methods, ITestContext context) {
// TODO Auto-generated method stub\
// IMethodInstance 这个接口所返回的是所有测试方法或实例（所有方法都在里面）
// 将IMethodInstance对象的list 创建为迭代器
Iterator<IMethodInstance> tie = methods.iterator();
// 遍历
while (tie.hasNext()) {
IMethodInstance methon = tie.next();
// 带注释的TestNG方法
ITestNGMethod x = methon.getMethod();
// 判断这个方法时@注释描述的
if (x.isTest()) {
// 取出所有的groups遍历
for (String groupName : x.getGroups())
// 判断组名
if (groupName.contentEquals("haha")) {
// 如果正确添加到执行list（之所以说是执行list，因为这个list要被return，list里面有的元素才会被执行）
returnMethod.add(methon);
}
}
}
// return
return returnMethod;
}
}
执行类
@Listeners({ListenerTwo.class})
public class ListenerOne {
@BeforeTest
public void set() throws Exception {
System.out.println("@BeforeTest");
}
@Test(groups = "haha")
public void test() throws Exception {
System.out.println("@Test");
}
@AfterTest
public void down() throws Exception {
System.out.println("@AfterTest");
}
@Test(groups = "lalal")
public void gugu(){
System.out.println("111");
}
@Test(groups ={ "haha","lala"})
public void lili(){
System.out.println("@2222");
}
@Test
public void bilibilibili(){
System.out.println("@bilibilibili");
}
@Test(groups = "haha")
public void acfun(){
int a = 1/0;
System.out.println(a);
}
}
执行结果
---------------------------------------------------------------------------分割线-------------------------------------------------------------------------------------------
贴上官源码（根据本地电脑系统来运行方法：解释过来就是把系统名称赋值给组名，然后利用监听来控制组的运行）
注:此代码是需要配合上一篇监听文章一起使用
代码块：
1.事先定义好组名称
package listeners;
public class OSNames {
public static final String OS_WINDOWS = "OS_Windows";
public static final String OS_LINUX = "OS_Linux";
public static final String OS_UNKNOWN = "OS_Unknown";
}
2.重写 IMethodInterceptor 监听类
package listeners;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;
import org.testng.IMethodInstance;
import org.testng.IMethodInterceptor;
import org.testng.ITestContext;
import org.testng.ITestNGMethod;
import org.testng.annotations.Test;
public class OSFilter implements IMethodInterceptor {
public static int totalIgnored = 0;
public static int totalRun = 0;
public static int totalConfigured = 0;
private List<IMethodInstance> methodsToTest = null;
public boolean isQualified(ITestNGMethod iTestNGMethod) {
boolean isQualified = false;
Method m = iTestNGMethod.getConstructorOrMethod().getMethod();
Test testAnno = m.getAnnotation(Test.class);
String[] groups = testAnno.groups();
List<String> groupList = Arrays.asList(groups);
String osName = getCurrentOS();
if (groupList.contains(osName)) {
isQualified = true;
}
return isQualified;
}
private String getCurrentOS() {
String osname = System.getProperties().getProperty("os.name");
if (osname.startsWith("Windows")) {
return OSNames.OS_WINDOWS;
} else if (osname.equalsIgnoreCase("Linux")) {
return OSNames.OS_LINUX;
} else {
return OSNames.OS_UNKNOWN;
}
}
@Override
public List<IMethodInstance> intercept(List<IMethodInstance> methods,
ITestContext iTestContext) {
if (methodsToTest == null) {
SortedMap<String, IMethodInstance> sortedMap = new TreeMap<String, IMethodInstance>();
List<String> ignoredMethods = new ArrayList<String>();
for (Iterator<IMethodInstance> it = methods.iterator(); it
.hasNext();) {
IMethodInstance iMethodInstance = it.next();
ITestNGMethod m = iMethodInstance.getMethod();
String methodName = m.getConstructorOrMethod().getName();
String className = m.getTestClass().getRealClass().getName();
totalConfigured += 1;
if (isQualified(iMethodInstance.getMethod())) {
String sortKey = className + "_" + methodName;
sortedMap.put(sortKey, iMethodInstance);
totalRun += 1;
} else {
ignoredMethods.add(methodName + "(" + className + ")");
totalIgnored += 1;
}
}
List<IMethodInstance> rtMethods = new ArrayList<IMethodInstance>(
sortedMap.values());
ProgressTracker.totalRun = totalRun;
System.out.println("Ignored Test Methods: " + ignoredMethods);
methodsToTest = rtMethods;
}
return methodsToTest;
}
}
3.执行类
package tests;
import listeners.OSFilter;
import listeners.OSNames;
import listeners.ProgressTracker;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;
@Listeners({ OSFilter.class, ProgressTracker.class })
public class SampleTest {
@Test(groups = { OSNames.OS_LINUX })
public void test1() {
sleep(5000);
System.out.println(">>>test1");
}
@Test(groups = { OSNames.OS_LINUX, OSNames.OS_WINDOWS })
public void test2() {
sleep(3000);
System.out.println(">>>test2");
}
@Test(groups = { OSNames.OS_LINUX, OSNames.OS_WINDOWS })
public void test3() {
sleep(2000);
System.out.println(">>>test3");
}
@Test(groups = { OSNames.OS_WINDOWS })
public void test4() {
sleep(5000);
System.out.println(">>>test4");
}
@Test(groups = { OSNames.OS_WINDOWS })
public void test5() {
sleep(5000);
System.out.println(">>>test5");
}
private void sleep(long time) {
try {
Thread.sleep(time);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
这样配合使用完美的监听就出来了
结语：小白踩坑记
