Java基础-注解元注解

Posted Ocean:)

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java基础-注解元注解相关的知识,希望对你有一定的参考价值。

注解

Java注解也称Java标注,是jdk1.5(5.0)后的新特征。Java语言中的类、方法、变量、参数和包等都可以被标注。和Javadoc不同,Java注解可以通过反射获取标注内容,在编译器生成类文件时,标注可以被嵌入到字节码中,Java虚拟机可以保留标注内容,在运行时可以获取到标注内容,当然它也支持自定义Java标注

功能:用于说明程序

用途:一般用在框架中使用

格式:@AnnotationName

文档注释:

​ @param @return @Exception从根本上是一个注释,不存在代码编译,不会生成对应的文档

注解:

​ @Override并不是没有编译就有效果,是因为不管是Eclipse还是IDEA都可以预编译Java代码生成对应的.class文件的

注解作用

  • 生成文档

    代码中生成对应的JavaDoc API文档

    @param @return

    【IDEA JavaDoc工具使用参数】

    ​ Other Command Line Arguments:-encoding utf-8 -charset utf-8

    ​ 解决中文乱码,因为IDEA默认编码集为UTF-8 windows默认编码集为 GBK

  • 代码检查

    继承重写,或者说接口遵从之后的实现中,存在@Override

  • 代码数据获取:【小型框架】

    通过反射获取指定注解中的一些内容,例如:配置,数据,操作,验证等

Java预定义的注解

  • @Override

    ​ 重写/实现方法的情况下,检查方法声明是否和父类或者接口中的方法声明一致,强制格式检查

  • @Deprecated

    标记当前方法已过时

  • @SuppressWarnings(“all”)

    压制警告,可以用于一些代码中存在明确无异常的情况下,压制一些警告

Annotation注解属性【难点】

  • 属性

    ​ 开发实际使用注解的方式中,数据使用方式更加偏向于属性概念

    ​ 使用

    1. 书写代码中使用

      @MyAnnotation(id=1, name=“ocean”, age=16)

    2. 使用反射时,会涉及到getXXX方法

      通过属性名获取对应值的概念来完成的

    实际上是利用abstract方法来完成属性概念的

  • 属性使用的格式【实际按照方法格式操作】

    1. 属性的值数据类型和对应的具体数据 => 返回值类型和返回的数据属性类型支持:
      • 基本数据类型
      • String类型
      • 其他数据类型
      • enmu枚举类型,一个带有名字的常量,为了更好的阅读性和操作
      • 以上类型对应的数组
    2. 属性值要求
      • 定义属性时可以使用default关键字,加上默认值,该属性在使用的过程中是没有强制要求属性值,如果没有赋予属性值,采用对应的默认值操作,如果赋值,使用对应值

      • 如果注解中有且只有一个value属性,或者说注解中除value属性之外,都有默认值,不管是类,方法,成员变量,包使用当前注解是可以直接在括号内加入
        对应数据类型数值

        • 如果属性是数组类型, {}大括号保存,并且不同的内容,使用,隔开属性的键名字 ==> 方法的名字

自定义注解

格式:
	public @interface AnnotationName {
		属性列表;
	}
	
Annotation注解是可以编译得到对应的.class字节码文件,验证了注解是可以参与编译过程的

通过反编译工具可以得到一下内容
【Annotation本质】
public interface MyAnnotation1 extends java.lang.annotation.Annotation {
}

MyAnnotation1
	本质是一个interface,同时java.lang.annotation.Annotation 子接口
package cn.ocean888.a_annotation.MyAnnotation;

/**
 * 自定义注解!!!
 * public interface MyAnnotation1 extends java.lang.annotation.Annotation {
 * }
 *
 * @author Anonymous
 * @date 2020/3/10 11:01
 */
public @interface MyAnnotation1 {
    // 属性 ==> 方法形式
}

元注解

基于注解的解释,用来约束注解的的一些操作问题

  • @Retention

    表示这个注解的保存方式,是只在代码中,还是编入class文件中,或者是运行时可以通过反射访问

    RetentionPolicy.RUNTIME:当前注解会编译生成对应的.class字节码文件,并且可以加载到JVM中,参与代码执行

    RetentionPolicy.CLASS

    RetentionPolicy.SOURCE:注解将被编译器丢弃(该类型的注解信息只会保留在源码里,源码经过编译后,注解信息会被丢弃,不会保留在编译好的class文件里)

  • @Document

    标记这些注解是否包含在用户文档中

    是否可以通过JavaDoc工具,生成对应的API文档

  • @Target

    标记这个注解应该是那种Java成员

    属性:ElementType

    ​ TYPE:当前注解可以用于类声明

    ​ METHOD:当前注解可以用于方法声明位置

    ​ FIELD:当前注解可以用于成员变量声明位置

  • @Inherited

    标记这个注解是继承于那个注解类(默认 注解不继承于任何子类)

获取类上的注解

Java获取类上的注解有下面3个方法:

  • Class.getAnnotations() 获取所有的注解,包括自己声明的以及继承的
  • Class.getAnnotation(Class< A > annotationClass) 获取指定的注解,该注解可以是自己声明的,也可以是继承的
  • Class.getDeclaredAnnotations() 获取自己声明的注解、

java.lang.Class类的isAnnotation()方法用于检查此Class是否为Annotation类型

java.lang.Class类的isAnnotationPresent()方法用于检查此类中是否存在指定注释类型的注释

实例:

实例1:两种属性文件的加载的方式

1.properties

className = cn.ocean888.a_annotation.Person
id = 1
name = "ocean"

Person类

package cn.ocean888.a_annotation;

public class Person {
    Integer id;
    String name;

    public Person() {
    }

    public Person(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\\'' +
                '}';
    }
}

第一种使用反射来完成

package cn.ocean888.a_annotation;

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.Properties;

public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, IOException, NoSuchFieldException {
        Properties properties = new Properties();
        properties.load(new FileInputStream("./src/1.properties"));

        String className = properties.getProperty("className");
        String id = properties.getProperty("id");
        String name = properties.getProperty("name");
        System.out.println(className);

        /*
        使用反射的方法
         */
        Class<?> aClass = Class.forName(className);
        Person person = (Person) aClass.getConstructor().newInstance();
        System.out.println(person);

        Field declaredField = aClass.getDeclaredField("id");
        declaredField.setAccessible(true);
        declaredField.set(person, Integer.parseInt(id));

        Field declaredField2 = aClass.getDeclaredField("name");
        declaredField2.setAccessible(true);
        declaredField2.set(person, name);

        System.out.println(person);
    }
}

第二种使用反射加注解的方式来完成

自定义注解

package cn.ocean888.a_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)
@interface MyAnnotaion1 {
    // 属性
    String className();
    int id();
    String name();
}

ReflectAnnotation.java

package cn.ocean888.a_annotation;

import java.lang.annotation.Annotation;

@MyAnnotaion1(className = "cn.ocean888.a_annotation.Person",
    id = 2,
    name = "ocean")
public class ReflectAnnotation {
    public static void main(String[] args) {
        // 加载ReflectAnnotation
        Class<ReflectAnnotation> cls = ReflectAnnotation.class;

        // 因为注解再类名之上,通过Class获取对应的Annotation
        MyAnnotaion1 annotation = cls.getAnnotation(MyAnnotaion1.class);

        String s = annotation.className();
        int id = annotation.id();
        String name = annotation.name();

        System.out.println(s);
        System.out.println(id);
        System.out.println(name);
    }
}

实例2使用注解测试代码运行

对Tools方法中带有@Check注解标记的方法进行检查

Tools.java

package cn.ocean888.a_annotation_checkMethod;

import java.util.ArrayList;

/**
 * 需要测试的方法
 */
public class Tools {
    @Check
    public void test1() {
        String str = null;
        System.out.println(str.toString());
    }

    @Check
    public void test2() {
        int[] arr = null;
        System.out.println(arr[5]);
    }

    @Check
    public void test3() {
        int[] arr = {1,2,3,4,5};
        System.out.println(arr[3]);
    }

    @Check
    public void test4() {
        ArrayList<Integer> integers = new ArrayList<>();
        System.out.println(integers.get(20).toString());
    }

    @Check
    public void test5() {
        throw new NullPointerException("NullPointException");
    }
}

Utils.java

package cn.ocean888.a_annotation_checkMethod;

public class Utils {
    @Check
    public void test() {
        throw new IndexOutOfBoundsException("下标越界");
    }
}

Check.java

package cn.ocean888.a_annotation_checkMethod;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 该注解没有任何属性,只是作为是否需要测试的标记
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Check {
}

ClassAnnotation.java

package cn.ocean888.a_annotation_checkMethod;

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.TYPE)
public @interface ClassAnnotation {
    String className();
}

TestProject.java

package cn.ocean888.a_annotation_checkMethod;

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

/**
 * 测试Tools类内的方法,如果方法带有Check注解,执行测试并记录异常
 */
@ClassAnnotation(className = "cn.ocean888.a_annotation_checkMethod.Tools")
public class TestProject {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, IOException {

        // 从注解中获取对应的属性
        Class<TestProject> testProjectClass = TestProject.class;
        // 获取所有指定的注解
        ClassAnnotation annotation = testProjectClass.getAnnotation(ClassAnnotation.class);
        String s = annotation.className();
        // s = cn.ocean888.a_annotation_checkMethod.Utils

        Class<?> aClass = Class.forName(s);

        Object tools = aClass.getConstructor().newInstance();
        // 获取所有Tools类内的方法,不包括父类方法
        Method[] declaredMethods = aClass.getDeclaredMethods();

        // 记录错误出现次数
        int count = 0;
        long l = System.currentTimeMillis();
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("./src/log.txt"));

        // 遍历方法数组
        for (Method declaredMethod : declaredMethods) {
            declaredMethod.setAccessible(true);

            // 判断当前方法是否带有注解@Check标记
            if (declaredMethod.isAnnotationPresent(Check.class)) {
                try {
                    declaredMethod.invoke(tools);
                } catch (Exception e) {
                    count += 1;

                    // 1.哪一个方法出现异常
                    bufferedWriter.write("方法:" + declaredMethod.getName());
                    bufferedWriter.newLine();
                    // 2.发生异常原因,获取对应的类型
                    bufferedWriter.write("异常类型:" + e.getCause().getClass().getSimpleName());
                    bufferedWriter.newLine();
                    // 3.异常信息
                    bufferedWriter.write("异常信息:" + e.getCause().getMessage());

                    bufferedWriter.newLine();

                }
            }
        }

        long l1 = System.currentTimeMillis();
        bufferedWriter.write("出现错误的次数" + count);
        bufferedWriter.newLine();
        bufferedWriter.write("总耗时" + (l1 - l));

        bufferedWriter.close();
    }
}

代码的灵活性在于可以对className直接进行替换

注解使用总结

  1. 注解在大多数情况下,都是使用过程,而不是自定义,会使用到框架中预处理好的注解
  2. 注解使用对象
    • 编译器
    • 解析代码
    • JVM运行代码使用
  3. 注解是一个标签,有时候是做标记,有时候标记有属性

注解和python装饰器的区别

先说java的注解(Annotation),实际上是给语法元素打一个标记。比如你可以给一个函数打一个标记,给一个类打一个标记等等。Java只保证记录这个标记,但是不会主动根据这给标记做任何事。

比如,你在Spring里,给一个私有成员打 @Autowired 这个标记。

public class XXXService {

@Autowired
private XXXXRepository xxxxRepository;

// ...
}

如果你不用Spring框架的话,不会有任何事情发生,直接访问这个字段就是空。当如果你配置了合适的处理流程,而这个流程就会根据有没有这个标记干活。比如你要求Spring “Auto Scan” 并且注入依赖,这个处理过程会用反射去读哪些元素被做了某个特定标记。没有标记就不理,有标记就注入。

python里的decorator是一个语法糖,是希望把“decorator”这个形式写得更漂亮。比如,你想记录一个函数开始执行之前和之后的log:

def foo():
print("Hello")

def logit(fn):
def inner():
print("before execute")
fn()
printf("after execute")
return inner

这时,你可以魔改以下foo的实现,用logit这个“装饰器”来部分修改foo的行为,然后执行:

foo = logit(foo)
foo()

但python里的语法可以让这个东西写成:

@logit
def foo():
print("Hello")

foo()

也就是说,python这里的装饰器是一个有逻辑的,可以执行的函数,只不过其写法有些特殊要求;而Java里面的Annotation只是个标记,需要其他代码来“根据标记执行“。

当然,装饰器模式是个很通用的东西,无论是python,java还是其他语言都可以写。只是python提供了特殊的语法糖而已。但java世界里做类似decorator的事情,希望动态魔改一个函数的行为,可以用动态代理或者AOP。

Java的Annotation因为相当于多加了一层(标记 + 处理逻辑),是一把双刃剑。好处是,在不动代码的情况下你可以通过外部配置来修改程序的行为。比如给一个函数打上@Test标。如果通过UT框架运行,这些打标的函数会被当作是测试用例;但如果外部直接用普通的main启动,这些@Test就会没有一样,不会影响代码本身的逻辑。但反过来,也容易引来一些问题。比如有的时候,你很难知道那个根据标记执行的逻辑是不是真的跑了。也许你哪里配置拼错一个字,或者classpath少依赖一个包,就造成那个逻辑并没有真的执行。这时从表面上也许很难看出来出错了。

以上是关于Java基础-注解元注解的主要内容,如果未能解决你的问题,请参考以下文章

JAVA基础:注解与反射的使用方法与场景

JavaLearn#(20)注解元注解模拟MyBatis注解JDK新特性数据库建模UML建模

JavaLearn#(20)注解元注解模拟MyBatis注解JDK新特性数据库建模UML建模

Java注解

Java注解

java自定义注解