【JavaWeb 注解】快速了解注解的概念、分类以及使用自定义注解完成简单的测试异常框架类

本文主要是介绍【JavaWeb 注解】快速了解注解的概念、分类以及使用自定义注解完成简单的测试异常框架类，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

注解

本文是java课程图文做的笔记

0. 注解和注释的区别

注解：说明程序的。给计算机看的
注释：用文字描述程序的。给程序员看的，方便阅读程序

1. 注解的概念

注解（Annotation）：也叫元数据。一种代码级别的说明。
它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。
它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

2. 注解的使用方法

使用注解：@注解名称

3. 注解的作用分类

①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

3.1 javadoc注解

小技巧：在idea中输入/**回车即可出现
可以在命令行窗口使用javadoc命令运行.java文件生成.html等文档

package annotation;
/**
 - 注解javadoc演示
 -  * @author 
 - @version 
 - @since 1.5
 */
public class AnnoDemo1 {
    /**
     * 计算两数的和
     * @param a 整数
     * @param b 整数
     * @return 两数的和
     */
    public int add(int a, int b ){
        return a + b;
    }
    /**
    * @Description: sum
    * @Param: [a, b]
    * @return: int
    * @Author: 
    * @Date:    
    */
    public  int summ(int a,int b){
        return a+b;
    }
}

3.2 自定义注解

@Override ：检测被该注解标注的方法 是否是继承自父类(接口) 的
@Deprecated：该注解标注的内容，表示已过时
@SuppressWarnings：压制警告 一般传递参数all @SuppressWarnings(“all”)

@SuppressWarnings("all")  //压制所有的黄色警告信息
public class AnnoDemo2 {
 @Override
    public String toString() {  //重写toString方法的时候会自动生成@Override注解，作一个检查
        return super.toString();
    }

    @Deprecated//过期注解
    public void show1(){  //表明这个方法能用但是不推荐用
        //有缺陷
    }

    public void show2(){
        //替代show1方法
    }

    public void demo(){
        show1();
        Date date = new Date();
    }
}

3.3 自定义注解

格式：
元注解
public @interface 注解名称{ 属性列表; }
本质：注解本质上就是一个接口，该接口默认继承Annotation接口
public interface MyAnno extends java.lang.annotation.Annotation {}
属性：接口中的抽象方法
1. 要求：属性的返回值类型有下列取值
  基本数据类型
  - String
  - 枚举
  - 注解
  - 以上类型的数组

public @interface MyAnno {

	int value();
	Person per();
	MyAnno2 anno2();
    String[] strs();
     /*String name() default "张三";*/
     /*String show2();

    Person per();
    MyAnno2 anno2();
	String[] strs();*/
}

定义了属性，在使用时需要给属性赋值
1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。

 String name() default "张三";

如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
@SuppressWarnings(“all”) 没有写属性名，只有值

3.数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略

@MyAnno(value=12,per = Person.P3,anno2 = @MyAnno2,strs={"bbb","aaa"})

3.4 元注解：用于描述注解的注解

@Target ：描述注解能够作用的位置
- ElementType取值：
  - TYPE：可以作用于类上
  - METHOD：可以作用于方法上
  - FIELD：可以作用于成员变量上
@Retention：描述注解被保留的阶段

@Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到,一般自己定义的注解都是这个

@Documented：描述注解是否被抽取到api文档中
@Inherited：描述注解是否被子类继承

package annotation;

import java.lang.annotation.*;

@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited

public @interface MyAnno3 {
}

3.5 在程序使用(解析)注解：获取注解中定义的属性值

注解大部分时候都是是用来替换配置文件的

1. 获取**注解定义的位置的对象**  （Class，Method,Field）
2. 获取指定的注解
	* getAnnotation(Class)
	//其实就是在内存中生成了一个该注解接口的子类实现对象

            public class ProImpl implements Pro{
                public String className(){
                    return "annotation.Demo1";
                }
                public String methodName(){
                    return "show";
                }
            }
3. 调用注解中的抽象方法获取配置的属性值

定义注解pro

package annotation;


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

/**
 * 描述需要执行的类名，和方法名
 */

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Pro {

    String className();//代表了一套规范
    String methodName();
}

使用注解来完成框架类，而不是配置文件

package annotation;

import java.lang.reflect.Method;

/**
 * 框架类
 */

@Pro(className = "annotation.Demo1",methodName = "show")
public class ReflectTest {
    public static void main(String[] args) throws Exception {
      
        // 1.解析注解
        // 1.1 获取该类的字节码文件对象
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        
        // 1.2 获取上边的注解对象
        //其实就是在内存中生成了一个该注解接口的子类实现对象
        
        /*
            public class ProImpl implements Pro{
                public String className(){
                    return "annotation.Demo1";
                }
                public String methodName(){
                    return "show";
                }
            }
		 */

        Pro an = reflectTestClass.getAnnotation(Pro.class); //相当于上面的类
        
        // 1.3.调用注解对象中定义的抽象方法，获取返回值
        String className = an.className();
        String methodName = an.methodName();
        System.out.println(className);
        System.out.println(methodName);

        // 3.加载该类进内存
        Class cls = Class.forName(className);
        // 4.创建对象
        Object obj = cls.newInstance();
        // 5.获取方法对象
        Method method = cls.getMethod(methodName);
        // 6.执行方法
        method.invoke(obj);
    }
}

4. 总结

大多数时候，会使用注解，而不是自定义注解
注解给谁用？
1. 编译器
2. 给解析程序用
注解不是程序的一部分，可以理解为注解就是一个标签

5. 使用注解完成简单的测试异常框架

创建简单的计算器类，并加上@check注解：

package annotation.demo;

public class Calculator {

    //加法
    @Check
    public void add(){
        String str = null;
        str.toString();
        System.out.println("1 + 0 =" + (1 + 0));
    }
    //减法
    @Check
    public void sub(){
        System.out.println("1 - 0 =" + (1 - 0));
    }
    //乘法
    @Check
    public void mul(){
        System.out.println("1 * 0 =" + (1 * 0));
    }
    //除法
    @Check
    public void div(){
        System.out.println("1 / 0 =" + (1 / 0));
    }
    public void show(){
        System.out.println("无bug...");
    }

}

写@check注解：

package annotation.demo;


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

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)

public @interface Check {
}

写TestCheck类：

package annotation.demo;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Method;

/**
 * 简单的测试框架
 *
 * 当主方法执行后，会自动自行被检测的所有方法(加了Check注解的方法)，判断方法是否有异常，记录到文件中
 */
 
public class TestCheck {
    public static void main(String[] args) throws IOException {
        //1.创建计算器对象
        Calculator c = new Calculator();
        //2.获取字节码文件对象
        Class cls = c.getClass();
        //3.获取所有方法
        Method[] methods = cls.getMethods();

        int number = 0;//出现异常的次数
        BufferedWriter bw = new BufferedWriter(new FileWriter("bug.txt"));


        for (Method method : methods) {
            //4.判断方法上是否有Check注解
            if(method.isAnnotationPresent(Check.class)){
                //5.有，执行
                try {
                    method.invoke(c);
                } catch (Exception e) {
                    //6.捕获异常

                    //记录到文件中
                    number ++;

                    bw.write(method.getName()+ " 方法出异常了");
                    bw.newLine();
                    bw.write("异常的名称:" + e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("异常的原因:"+e.getCause().getMessage());
                    bw.newLine();
                    bw.write("--------------------------");
                    bw.newLine();

                }
            }
        }

        bw.write("本次测试一共出现 "+number+" 次异常");

        bw.flush();
        bw.close();
    }

}

在这里插入图片描述

这篇关于【JavaWeb 注解】快速了解注解的概念、分类以及使用自定义注解完成简单的测试异常框架类的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

【JavaWeb 注解】快速了解注解的概念、分类以及使用自定义注解完成简单的测试异常框架类

注解

0. 注解和注释的区别

1. 注解的概念

2. 注解的使用方法

3. 注解的作用分类

3.1 javadoc注解

3.2 自定义注解

3.3 自定义注解

3.4 元注解：用于描述注解的注解

3.5 在程序使用(解析)注解：获取注解中定义的属性值

4. 总结

5. 使用注解完成简单的测试异常框架

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯