三、junit接口自动化框架-自定义注解-注解检查

原创

wx63186321c235c 2022-09-08 10:31:21 博主文章分类：JAVA测开 ©著作权

文章标签 自动化运维 java sed 内部类 文章分类 后端开发

©著作权归作者所有：来自51CTO博客作者wx63186321c235c的原创作品，请联系作者获取转载授权，否则将追究法律责任

junit5的自带注解，不能满足需要，所以我们自定义一些注解

三、junit接口自动化框架-自定义注解-注解检查_运维

自定义注解：

1、自定义注解，@CaseTitle 用例标题 @CaseTag @CaseTags 用例标签，可以打多个，所以有数组 @CheckPoint @CheckPoints 用例检查点，可以是多个。

一、Java自定义注解：

举例一：@CaseDesc

1、新建注解 new Java Class -》Annotation

三、junit接口自动化框架-自定义注解-注解检查_sed_02

package com.example.autoapi.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.ANNOTATION_TYPE,ElementType.METHOD}) // Target表示将来这个注解应用在哪些方面。注解可以应用在类上、方法上（此处只应用在方法上）
@Retention(RetentionPolicy.RUNTIME) //运行时，使用这个这个注解
public @interface CaseDesc {
    String desc();
    String owner();
}

注解编写：

1、运行时，使用这个注解：

@Retention(RetentionPolicy.RUNTIME)

2、该注解作用域，可以作用在类/方法上。此处我们只作用在方法上

@Target({ElementType.ANNOTATION_TYPE,ElementType.METHOD})

3、注解的具体内容，我们编写的是@CaseDesc注解，里面包含描述信息和维护者

String desc();

String owner();

举例二：@CaseTag @CaseTags

@CaseTag，用例的tag，与@CaseDesc的区别是，用例可以写多个@CaseTag 。

@CaseTag

package com.example.autoapi.annotation;

import java.lang.annotation.*;

@Target({ElementType.ANNOTATION_TYPE,ElementType.METHOD}) // Target表示将来这个注解应用在哪些方面。注解可以应用在类上、方法上（此处只应用在方法上）
@Retention(RetentionPolicy.RUNTIME) //运行时，使用这个这个注解
@Repeatable(CaseTags.class) // 支持多个CaseTag
public @interface CaseTag {
    String key();
    String value();
}

@CaseTags

package com.example.autoapi.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.ANNOTATION_TYPE,ElementType.METHOD}) // Target表示将来这个注解应用在哪些方面。注解可以应用在类上、方法上（此处只应用在方法上）
@Retention(RetentionPolicy.RUNTIME) //运行时，使用这个这个注解
public @interface CaseTags {
    CaseTag[] value();
}

@CaseTags的内容，是@CaseTag的数组

在@CaseTag上使用@Repeatable(CaseTags.class) ，将两者关联起来。

这样就可以在方法上写多个@CaseTag注解了。

完成以上步骤（以上只是单纯的使用Java的能力写注解），就可以使用这些注解了。可以在case上使用这些注解，但是这些注解没有具体的功能。

想要有具体的功能，我们要将这些自定义注解结合junit5框架。

二、我们要实现哪些功能？

1、注解自身格式的检查（注解是否为空，注解内容是否填写正确）

2、根据注解不同来筛选运行case

3、在case上打报警标签

等

三、自定义注解与junit5框架相结合--注解自身格式的检查

思路：

1、自定义注解@AutoTest，作为一个载体，来收集使用@AutoTest 注解的测试case上所有的注解

测试方法/case使用@AutoTest注解
拿到这个测试方法的名字
利用反射原理，拿到这个测试方法上的所有注解
然后对所有注解进行处理

@AutoTest

package com.example.autoapi.annotation;

import com.example.autoapi.extension.CaseAnnotationCheckExtension;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.ANNOTATION_TYPE,ElementType.METHOD}) // Target表示将来这个注解应用在哪些方面。注解可以应用在类上、方法上（此处只应用在方法上）
@Retention(RetentionPolicy.RUNTIME) //运行时，使用这个这个注解
@Test
@ExtendWith(CaseAnnotationCheckExtension.class) // 与junit结合，由junit提供。自定义一个扩展类，然后放到这里。走我们的自定义类
public @interface AutoTest {
}

1、要写@Test，这个是junit5运行case用的

2、@ExtendWith(CaseAnnotationCheckExtension.class)

与junit结合，由junit提供。自定义一个扩展类，然后放到这里。走我们的自定义类。

在这个自定义类里，我们收集所有的注解，然后进行处理

CaseAnnotationCheckExtension

package com.example.autoapi.extension;

import com.example.autoapi.annotation.CaseTitle;
import com.example.autoapi.check.ObserverManager;
import org.junit.jupiter.api.extension.BeforeTestExecutionCallback;
import org.junit.jupiter.api.extension.ExtensionContext;

import java.lang.reflect.Method;

// 自定义的扩展类，必须实现框架提供的BeforeTestExecutionCallback接口
// BeforeTestExecutionCallback 在执行case之前，先执行我们的回调
public class CaseAnnotationCheckExtension implements BeforeTestExecutionCallback {
    @Override
    public void beforeTestExecution(ExtensionContext extensionContext) throws Exception {
        Method requiredTestMethod = extensionContext.getRequiredTestMethod(); //拿到使用该注解的方法/测试case
        ObserverManager.of().check(requiredTestMethod); // 利用观察者模式对case上的方法依次进行检查

    }
}

自定义扩展类：CaseAnnotationCheckExtension

要想在junit5框架里，使用这个自定义扩展类，必须实现接口BeforeTestExecutionCallback

BeforeTestExecutionCallback 在执行case之前，先执行我们的回调。

ObserverManager.of().check(requiredTestMethod); // 利用观察者模式对case上的方法依次进行检查

三、junit接口自动化框架-自定义注解-注解检查_运维

这里我们使用了观察者设计模式，因为要检查很多个注解。

观察者设计模式：

1、我们要写很多个检查方法，比如检查@CaseTitle，注解是否必填，格式是否正确。

检查@CaseTag，注解是否必填，格式是否正确等等，我们要针对每一个注解写一个检查方法。

2、定义观察者接口，里面有检查方法

AnnotationCheckObserver

package com.example.autoapi.check;

import java.lang.reflect.Method;

// 观察者模式
// 每个注解的检查都实现这个接口，便于统一管理/校验注解
public interface AnnotationCheckObserver {
    void check(Method method);
}

3、每个注解的检查都实现这个接口，便于统一管理/校验注解

CaseTitleCheck

package com.example.autoapi.check;

import com.example.autoapi.annotation.CaseTitle;
import com.example.autoapi.exception.IllegaFormatException;
import com.example.autoapi.util.RequireUtil;

import java.lang.reflect.Method;

public class CaseTitleCheck implements AnnotationCheckObserver{
    @Override
    public void check(Method method){
        boolean titleSet = method.isAnnotationPresent(CaseTitle.class);
        // 判断注解CaseTitle是否存在
        if(!titleSet){
            throw new IllegaFormatException("title is must");
        }
        CaseTitle caseTitle = method.getAnnotation(CaseTitle.class);
        RequireUtil.requireNotNullOrEmpty(caseTitle.value(),"CaseTitle value is must.eg: @CaseTitle(\"标题\")");
    }
}

里面，写的是对应注解的检查方法

4、ObserverManager。管理所有的检查方法

package com.example.autoapi.check;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class ObserverManager {

    private final List<AnnotationCheckObserver> observers;

    // 构造器，私有，不能被new
    private ObserverManager(){
        observers = new ArrayList<>();
        observers.add(new CaseTitleCheck());// 添加，检查标题的方法
    }

    // ClassHolder属于静态内部类，在加载类Demo03的时候，只会加载内部类ClassHolder，
    // 但是不会把内部类的属性加载出来
    private static class ClassHolder{
        // 这里执行类加载，是jvm来执行类加载，它一定是单例的，不存在线程安全问题
        // 这里不是调用，是类加载，是成员变量
        private static final ObserverManager holder =new ObserverManager();

    }

    public static ObserverManager of(){//第一次调用getInstance()的时候赋值
        return ClassHolder.holder;
    }

    public void check(Method method){
        // 把case/方法 method ，依次接受各种检查
        for(AnnotationCheckObserver observer:observers){
            observer.check(method);
        }
    }



}

1、每个注解的检查类都实现了AnnotationCheckObserver 这个接口，实现了 check方法

每个类都属于AnnotationCheckObserver接口，所以创建一个集合，把所有的检查类都放在里面。

然后便利集合里面的元素，依次调用检查check方法。

----------------------------以上就是整个流程--------------------------

接下来完成，其他注解的检查

CaseDescCheck

package com.example.autoapi.check;

import com.example.autoapi.annotation.CaseDesc;
import com.example.autoapi.annotation.CaseTitle;
import com.example.autoapi.exception.IllegaFormatException;
import com.example.autoapi.util.RequireUtil;

import java.lang.reflect.Method;

public class CaseDescCheck implements AnnotationCheckObserver{
    @Override
    public void check(Method method){
        boolean caseDescSet = method.isAnnotationPresent(CaseDesc.class);
        // 判断注解CaseTitle是否存在
        if(!caseDescSet){
            throw new IllegaFormatException("CaseDesc is must");
        }
        CaseDesc caseDesc = method.getAnnotation(CaseDesc.class);
        RequireUtil.requireNotNullOrEmpty(caseDesc.desc(),"CaseDesc desc is must.eg: @CaseDesc(desc=\"描述\"，owner=\"管理者\")");
        RequireUtil.requireNotNullOrEmpty(caseDesc.owner(),"CaseDesc owner is must.eg: @CaseDesc(desc=\"描述\"，owner=\"管理者\")");

    }
}

CaseTagCheck

package com.example.autoapi.check;

import com.example.autoapi.annotation.CaseDesc;
import com.example.autoapi.annotation.CaseTag;
import com.example.autoapi.exception.IllegaFormatException;
import com.example.autoapi.util.RequireUtil;

import java.lang.reflect.Method;

public class CaseTagCheck implements AnnotationCheckObserver{
    @Override
    public void check(Method method){
        CaseTag[] caseTags = method.getAnnotationsByType(CaseTag.class);
        // 判断是否有CaseTag注解
        // 因为可以写多个，这里获取的是一个数组
        // 数组长度为0时，报异常
        if(caseTags.length==0){
            throw new IllegaFormatException("CaseTag is must");
        }
        for(CaseTag caseTag:caseTags){

            RequireUtil.requireNotNullOrEmpty(caseTag.key(),"CaseTag key is must.eg: @CaseTag(key=\"key\"，val=\"val\")");
            RequireUtil.requireNotNullOrEmpty(caseTag.val(),"CaseTag val is must.eg: @CaseTag(key=\"key\"，val=\"val\")");

        }

    }
}

CheckPointCheck

package com.example.autoapi.check;

import com.example.autoapi.annotation.CaseTag;
import com.example.autoapi.annotation.CheckPoint;
import com.example.autoapi.exception.IllegaFormatException;
import com.example.autoapi.util.RequireUtil;

import java.lang.reflect.Method;

public class CheckPointCheck implements AnnotationCheckObserver{
    @Override
    public void check(Method method){
        CheckPoint[] checkPoints = method.getAnnotationsByType(CheckPoint.class);
        // 判断是否有CaseTag注解
        // 因为可以写多个，这里获取的是一个数组
        // 数组长度为0时，报异常
        if(checkPoints.length==0){
            throw new IllegaFormatException("CheckPoint is must");
        }
        for(CheckPoint checkPoint:checkPoints){

            RequireUtil.requireNotNullOrEmpty(checkPoint.value(),"CheckPoint is must.eg: @CheckPoint(xxx)");
        }

    }
}

ObserverManager

package com.example.autoapi.check;

import com.google.common.collect.Lists;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class ObserverManager {

    private final List<AnnotationCheckObserver> observers;

    // 构造器，私有，不能被new
    private ObserverManager(){
        observers = Lists.newArrayList(
                new CaseTitleCheck(),
                new CaseDescCheck(),
                new CaseTagCheck(),
                new CheckPointCheck()
        );
    }

    // ClassHolder属于静态内部类，在加载类Demo03的时候，只会加载内部类ClassHolder，
    // 但是不会把内部类的属性加载出来
    private static class ClassHolder{
        // 这里执行类加载，是jvm来执行类加载，它一定是单例的，不存在线程安全问题
        // 这里不是调用，是类加载，是成员变量
        private static final ObserverManager holder =new ObserverManager();

    }

    public static ObserverManager of(){//第一次调用getInstance()的时候赋值
        return ClassHolder.holder;
    }

    public void check(Method method){
        // 把case/方法 method ，依次接受各种检查
        for(AnnotationCheckObserver observer:observers){
            observer.check(method);
        }
    }



}