【Java基础】-- Annotation 注释基本使用

作者: 未城居士 | 来源:发表于2022-01-18 14:34 被阅读0次

Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。对于 Java 开发而言，Spring 的广泛使用下对于注解的理解是非常重要的，它让我们的代码更加美观优雅。

介绍

Java 定义了一套注解，共有 7 个，3 个在 java.lang 中，剩下 4 个在 java.lang.annotation 中。

代码辅助类

@Override

用于说明此方法覆盖超类型中的方法声明。可以是父类定义的或者是 Object 中定义的。

public class BaseClass {
    
    protected void future() {}
    
}

public class FutureClass extends BaseClass {

    @Override
    protected void future() {
        super.future();
    }

    @Override
    public String toString() {
        return super.toString();
    }
    
}

@Deprecated

用来接口、成员方法和成员变量等，表示已经过时。

实际使用中，规范场景下可以在代码校验的时候识别到替换到新的类或方法。

@SuppressWarnings

编译器去忽略注解中声明的警告。

元注解类

@Retention

标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问。

@Documented

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

@Target

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

@Inherited

标记这个注解是可以被继承的。

Java7及之后注解

@SafeVarargs

在声明具有模糊类型（比如：泛型）的可变参数的构造函数或方法时，Java 编译器会报 unchecked 警告。鉴于这些情况，如果程序员断定声明的构造函数和方法的主体不会对其 var args 参数执行潜在的不安全的操作，可使用 @SafeVarargs 进行标记，这样的话，Java 编译器就不会报 unchecked 警告。

@FunctionalInterface

Java 8 开始支持，标识一个匿名函数或函数式接口。只能有一个抽象方法。

@Repeatable

Java 8 开始支持，标识某注解可以在同一个声明上使用多次。

实战

RetentionPolicy 的应用

RetentionPolicy.CLASS 策略

注解代码：

@Retention(RetentionPolicy.CLASS)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface AnnotationForClass {
}

@AnnotationForClass
public class UseAnnotationForClass {
}

编译后：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.future.city.annotation;

@AnnotationForClass
public class UseAnnotationForClass {
    public UseAnnotationForClass() {
    }
}

可以看到编译后的 class 文件保留了 @AnnotationForClass

RetentionPolicy.SOURCE 策略

注解代码：

@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface AnnotationForSource {
}

@AnnotationForSource
public class UseAnnotationForSource {
}

编译后：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.future.city.annotation;

public class UseAnnotationForSource {
    public UseAnnotationForSource() {
    }
}

可以看到编译后的 class 文件没有注解。

RetentionPolicy.RUNTIME 策略

注解代码：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface AnnotationForRuntime {
}

@AnnotationForRuntime
public class UseAnnotationForRuntime {
}

测试代码

    public void test() {
        Annotation[] annotations = UseAnnotationForSource.class.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("Source - " + annotation.toString());
        }
        annotations = UseAnnotationForRuntime.class.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("Runtime - " + annotation.toString());
        }
    }

输出 Runtime - @com.future.city.annotation.AnnotationForRuntime() ，所以如果运行的时候需要去获取一些配置信息，比如 Dubbo 这种 RPC 框架 | Spring 的 @Service，注解策略就需要是 runtime 的。

@Inherited

注释代码：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface AnnotationForNoInherited {
}

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface AnnotationForInherited {
}

@AnnotationForInherited
@AnnotationForNoInherited
public class BaseInherited {
}

public class InheritedClass extends BaseInherited {
}

@AnnotationForInherited
@AnnotationForNoInherited
public interface InheritedInterface {
}

public class InheritedInterfaceImpl implements InheritedInterface {
}

测试代码：

    public void test() {
        Annotation[] annotations = BaseInherited.class.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("BI - " + annotation.toString());
        }
        annotations = InheritedClass.class.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("IC - " + annotation.toString());
        }
        annotations = InheritedInterface.class.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("II - " + annotation.toString());
        }
        annotations = InheritedInterfaceImpl.class.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("III - " + annotation.toString());
        }
    }

输出：

BI - @com.future.city.annotation.AnnotationForInherited()
BI - @com.future.city.annotation.AnnotationForNoInherited()
IC - @com.future.city.annotation.AnnotationForInherited()
II - @com.future.city.annotation.AnnotationForInherited()
II - @com.future.city.annotation.AnnotationForNoInherited()

可以看到类上面的注解有 @Inherited 才能把注解继承下去，接口的实现类是获取不到接口上的注解的。

@SafeVarargs 使用

public class UseSafeVarargs<T> {

    @SafeVarargs
    public UseSafeVarargs(List<String>... stringLists) {
    }

    @SafeVarargs
    static void staticMethod(List<String>... stringLists) {
        
    }

    @SafeVarargs
    final void finalMethod(List<String>... stringLists) {

    }

    // @SafeVarargs is not allowed on non-final instance methods
//    @SafeVarargs 
    @SuppressWarnings("unchecked")
    void normal(List<String>... stringLists) {
        
    }
    
}

@FunctionalInterface 使用

注释代码：

@FunctionalInterface
public interface FutureFunction<T, U> {

    U apply(T t);

    // Multiple non-overriding abstract methods found in interface com.future.city.annotation.FutureFunction
//    void run(T t, U u);

    default <V> FutureFunction<T, V> andThen(FutureFunction<? super U, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

}

测试代码：

    @Test
    public void test() {
        String s = "future city";
        FutureFunction futureFunction = (x) -> "Name is : " + x;
        System.out.println(futureFunction.apply(s));
    }

是有一种函数式编程，有些场景下可以根据条件获取函数，然后去执行，替代一些 IF-ELSE。

    public void test() {
        String s = "future city";
        FutureFunction futureFunction = (x) -> "Name is : " + x;
        System.out.println(futureFunction.andThen((x) -> x + " hahahaha~~").apply(s));
    }

默认函数，可以拿自己去加工，比如上面例子第一个函数在入参的前面加内容，第二个函数在入参的后面加参数。

@Repeatable 使用

注释代码：

@Repeatable(AnnotationForRepeatables.class)
public @interface AnnotationForRepeatable {

    String name();
    
}

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

    AnnotationForRepeatable[] value();
    
}

@AnnotationForRepeatable(name = "琦玉")
@AnnotationForRepeatable(name = "波罗斯")
@AnnotationForRepeatable(name = "饿狼")
@AnnotationForRepeatable(name = "爆破")
public class UseRepeatable {
}

测试代码：

    @Test
    public void test() {
        Annotation[] annotations = UseRepeatable.class.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("UR - " + annotation.toString());
        }
        AnnotationForRepeatables annotationForRepeatables = (AnnotationForRepeatables) annotations[0];
        for (AnnotationForRepeatable annotation : annotationForRepeatables.value()) {
            System.out.println("ForRepeatables -1 - " + annotation.toString());
        }
        annotationForRepeatables = UseRepeatable.class.getAnnotation(AnnotationForRepeatables.class);
        for (AnnotationForRepeatable annotation : annotationForRepeatables.value()) {
            System.out.println("ForRepeatables -2 - " + annotation.toString());
        }
    }

输出：

UR - @com.future.city.annotation.AnnotationForRepeatables(value=[@com.future.city.annotation.AnnotationForRepeatable(name=琦玉), @com.future.city.annotation.AnnotationForRepeatable(name=波罗斯), @com.future.city.annotation.AnnotationForRepeatable(name=饿狼), @com.future.city.annotation.AnnotationForRepeatable(name=爆破)])
ForRepeatables -1 - @com.future.city.annotation.AnnotationForRepeatable(name=琦玉)
ForRepeatables -1 - @com.future.city.annotation.AnnotationForRepeatable(name=波罗斯)
ForRepeatables -1 - @com.future.city.annotation.AnnotationForRepeatable(name=饿狼)
ForRepeatables -1 - @com.future.city.annotation.AnnotationForRepeatable(name=爆破)
ForRepeatables -2 - @com.future.city.annotation.AnnotationForRepeatable(name=琦玉)
ForRepeatables -2 - @com.future.city.annotation.AnnotationForRepeatable(name=波罗斯)
ForRepeatables -2 - @com.future.city.annotation.AnnotationForRepeatable(name=饿狼)
ForRepeatables -2 - @com.future.city.annotation.AnnotationForRepeatable(name=爆破)

直接获取类上面的注释得到的是 AnnotationForRepeatables 对象，要取它的 Value 才是 AnnotationForRepeatable 数组。

小结

注释整体还是比较简单易用的，作为日更的文章只介绍了最基本的使用。

一般项目中使用比较多的两点：

AOP 的使用，统一打印日志、权限控制or统一处理逻辑。
Spring 中定义了自己的注释来扫码到类做扩展点or策略的实现，如下面代码：

    @PostConstruct
    public void init() {
        Map<String, Object> extensionBeans = applicationContext.getBeansWithAnnotation(Extension.class);
        logger.warn("HEMA|TRADE|****** extensionRegister.doRegistration start ******");
        extensionBeans.values().forEach(
                extension -> extensionRegister.doRegistration((ExtensionPointI) extension)
        );
        logger.warn("HEMA|TRADE|****** extensionRegister.doRegistration end ******");
    }

趣味学习十二星座英语

Aries 白羊座
Taurus 金牛座
Gemini 双子座
Cancer 巨蟹座
Leo 狮子座
Virgo 处女座
Libra 天秤座
Scorpio 天蝎座
Sagittarius 射手座
Capricorn 摩羯座
Aquarius 水瓶座
Pisces 双鱼座

【Java基础】-- Annotation 注释基本使用

介绍

代码辅助类

@Override

@Deprecated

@SuppressWarnings

元注解类

@Retention

@Documented

@Target

@Inherited

Java7及之后注解

@SafeVarargs

@FunctionalInterface

@Repeatable

实战

RetentionPolicy 的应用

RetentionPolicy.CLASS 策略

RetentionPolicy.SOURCE 策略

RetentionPolicy.RUNTIME 策略

@Inherited

@SafeVarargs 使用

@FunctionalInterface 使用

测试代码：

@Repeatable 使用

小结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java语言