SeleniumAbstractTest.class

public abstract class SeleniumAbstractTest {

  @BeforeSuite
  public void beforeSuite() {
    System.out.println("BeforeSuite");
  }

  @BeforeTest
  public void beforeTest() {
    System.out.println("BeforeTest");
  }

  @BeforeClass
  public void beforeClass() {
    System.out.println("BeforeClass");
  }

  @BeforeMethod
  public void beforeMethod() {
    System.out.println("BeforeMethod");
  }

  @AfterMethod
  public void afterMethod() {
    System.out.println("AfterMethod");
  }

  @AfterClass
  public void afterClass() {
    System.out.println("AfterClass");
  }

  @AfterTest
  public void afterTest() {
    System.out.println("AfterTest");
  }

  @AfterSuite
  public void afterSuite() {
    System.out.println("AfterSuite");
  }

}

MyTestClass1.class

public class MyTestClass1 extends SeleniumAbstractTest {
  
  @Test
  public void myTestMethod1() {
    System.out.println("myTestMethod1");
  }

  @Test
  public void myTestMethod2() {
    System.out.println("myTestMethod2");
  }
}

MyTestClass2.class

public class MyTestClass2 extends SeleniumAbstractTest {
  
  @Test
  public void myTestMethod3() {
    System.out.println("myTestMethod3");
  }

  @Test
  public void myTestMethod4() {
    System.out.println("myTestMethod4");
  }
}

如果您有以下测试套件...

<suite name="Suite">
  <test name="Test1" >
    <classes>
       <class name="MyTestClass2" />
    </classes>
  </test>
 
  <test name="Test2">
    <classes>
      <class name="MyTestClass1"/>
      <class name="MyTestClass2"/>
    </classes>
  </test>
</suite>

...则输出[缩进以便于阅读]将为

BeforeSuite
'   BeforeTest
'   '   BeforeClass
'   '   '   BeforeMethod
'   '   '   '   myTestMethod3
'   '   '   AfterMethod
'   '   '   BeforeMethod
'   '   '   '   myTestMethod4
'   '   '   AfterMethod
'   '   AfterClass
'   AfterTest
'   BeforeTest
'   '   BeforeClass
'   '   '   BeforeMethod
'   '   '   '   myTestMethod1
'   '   '   AfterMethod
'   '   '   BeforeMethod
'   '   '   '   myTestMethod2
'   '   '   AfterMethod
'   '   AfterClass
'   '   BeforeClass
'   '   '   BeforeMethod
'   '   '   '   myTestMethod3
'   '   '   AfterMethod
'   '   '   BeforeMethod
'   '   '   '   myTestMethod4
'   '   '   AfterMethod
'   '   AfterClass
'   AfterTest
AfterSuite

@BeforeMethod -在每个测试方法之前执行，例如使用@Test注解的方法
@BeforeTest -仅在testng.xml文件中给定的标记之前执行。
简单地说，@BeforeMethod适用于Java类中定义的测试，而@BeforeTest适用于testng.xml（即XML文件）中定义的测试。

在解释区别之前，首先是一些测试术语
Test suite-由一个或多个测试标记组成。
Test tag-由一个或多个测试类组成。
Test class-由一个或多个方法组成。
例如

<suite name="suit1">
  <test name="TestTag1">
    <classes>
      <class name="TestClass1"/>
    </classes>
  </test>
  <test name="TestTag2">
    <classes>
      <class name="TestClass2"/>
      <class name="TestClass3"/>
    </classes>
  </test>
</suite>

@BeforeTest：在任何测试标记之前，它只被调用一次，无论该标记中有多少个测试类，或者有多少个用@Test注解的方法，对于每个测试标记，它只被调用一次，在前面的XML示例中，@BeforeTest将被调用两次，一次在TestTag1之前，第二次在TestTag2之前，因此它可用于初始化一个测试标签内的不同测试类之间的公共对象。
@BeforeClass：在任何测试类之前只调用一次，无论这个测试类中有多少个用@Test注解的方法，每个测试类只调用一次，在前面的XML示例中@BeforeClass将被调用三次，一次在TestClass1之前，第二次在TestClass2之前，第三次在TestClass3之前，因此它可用于初始化一个测试类内不同测试方法之间的公共对象。
将为suit1套件调用一次@BeforeSuite
呼叫顺序将如下

@BeforeSuite
    @BeforeTest
        @BeforeClass
            @BeforeMethod
                @Test

要了解有关@BeforeMethod的更多信息，请参阅答案https://stackoverflow.com/a/52331616/1973933

如果你从另一个类扩展，结果如下：

parentTest - BeforeTest- parent     
testClass1 - BeforeTest- test1    
parentTest - BeforeClass- parent    
testClass1 - BeforeClass- test1    
parentTest - BeforeMethod- parent    
testClass1 - BeforeMethod- test1    
testClass1 - myTestMethod1    
testClass1 - AfterMethod- test1    
parentTest - AfterMethod- parent    
parentTest - BeforeMethod- parent    
testClass1 - BeforeMethod- test1    
testClass1 - myTestMethod2    
testClass1 - AfterMethod- test1    
parentTest - AfterMethod- parent
testClass1 - AfterClass- test1    
parentTest - AfterClass- parent
testClass1 - AfterTest- test1
parentTest – AfterTest- parent

我的意见：
@BeforeClass：带注解的方法将在调用当前类 * 中的第一个测试方法 * 之前运行
@BeforeTest：带注解的方法将在运行当前套件 * 中的任何测试方法 * 之前运行

这是TestNG层次结构：测试套件-〉测试-〉类-〉方法
@BeforeTest在test标记内的所有类中的所有方法执行之前执行一次。

• • 另一方面;**

@BeforeClass在它所定义的类中的所有方法执行之前执行一次。
我已经把这个脚本上传到我的GitHub个人资料上了。这里有一个相同的链接。如果你喜欢的话，请竖起大拇指。
Please have a look at github:

@BeforeClass: The annotated method will be run before the first test method in the current class is invoked. 
@BeforeMethod: The annotated method will be run before each test method.

The annotations above will also be honored (inherited) when placed on a superclass of a TestNG class. This is useful for example to centralize test setup for multiple test classes in a common superclass.

In that case, TestNG guarantees that the "@Before" methods are executed in inheritance order (highest superclass first, then going down the inheritance chain), and the "@After" methods in reverse order (going up the inheritance chain).

要了解更多关于TestNG注解的信息：https://testng.org/doc/documentation-main.html#annotations

以上答案中缺少的是@BeforeClass和@BeforeTest注解之间的用法差异。
很明显，用@BeforeClass注解的方法（最常见的是setup方法）在类中编写的所有测试用例之前只执行一次，而用'@BeforeTest'注解的方法将在每个测试用例之前执行，而不管它们的计数/顺序/下划线逻辑如何。
因此，@BeforeClass用于我们的方法具有长调用和长执行时间，并且这些调用的输出不会被任何测试用例改变的情况。例如，在setup方法中获取API响应，这将被所有测试使用。然而，@BeforeTest@用于我们需要做一些清理工作，并且每个测试都需要一些新的资源来开始。例如，一个新创建的订单等。