越大的项目,使用注解就越清晰,代码可读性越高,维护起来就越简单。简单来说,通过注解,可以使我们的开发更方便简洁,通过规范约束我们的编程,避免一些不必要的错误,增强代码的描述性等。缺点就是理解起来有一定的难度,别人前期需要花费一些时间来理解这些注解。
注解的作用或者意义是什么
注解本身没有任何的意义,单独的注解就是一种注释,他需要结合其他如反射、注解处理器、插桩等技术才有意义。
注解的分类
根据注解的使用场景,主要分为三类,元注解、内置注解和自定义注解。
元注解
用于定义注解的注解,通常用于注解的定义上,标明该注解的使用范围、生效范围等。
元数据Annotation:包含成员变量的Annotation。默认值可用default设置。
public @interface MyAno {
String name() default "angela";
int age() default 18;
}
使用元数据需要设置默认值
@MyAno(name = "范冰冰", age = 15)
public class UserAno {
}
@Retention
指定注解信息保留到哪个阶段,分别为源代码阶段、编译Class阶段、运行阶段。
@Retention包含一个名为“value”的成员变量,该value成员变量是RetentionPolicy枚举类型。
1.RetentionPolicy.SOURCE:Annotation只保留在源代码中,编译器编译时,直接丢弃这种Annotation。
2.RetentionPolicy.CLASS:编译器把Annotation记录在class文件中。在编译时保存,当运行Java程序时,JVM中不再保留该Annotation。
3.RetentionPolicy.RUNTIME:编译器把Annotation记录在class文件中。当运行Java程序时,JVM会保留该Annotation,程序可以通过反射获取该Annotation的信息。
三种保留级别应用场景:
1.APT处理注解发生在编译器。
声明注解,限定参数传入类型,注解设置为源码级别。
@IntDef(value = {1, 2, 3, 4, 5})
@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.FIELD)
@interface Type {
}
public void setType(@Type int type) {
}
2.字节码增强
说人话就是在字节码中写代码。
@Target
不设置target可用于各种类型作为注解,也可同时设置多个target。
指定Annotation用于修饰哪些程序元素。@Target也包含一个名为”value“的成员变量ElementType为枚举类型.
ElementType.TYPE:能修饰类、接口或枚举类型
ElementType.FIELD:能修饰成员变量
ElementType.METHOD:能修饰方法
ElementType.PARAMETER:能修饰参数
ElementType.CONSTRUCTOR:能修饰构造器
ElementType.LOCAL_VARIABLE:能修饰局部变量
ElementType.ANNOTATION_TYPE:能修饰注解
ElementType.PACKAGE:能修饰包
内置注解
######@Documented
将此注解包含在 javadoc 中 ,它代表着此注解会被javadoc工具提取成文档。
######@Inherited
指定Annotation具有继承性。
######@Deprecated
用于表示某个程序元素(类、方法等)已过时
######@SuppressWarning
用来关闭编译器输出的警告信息
示例一:自定义注解简单例子:
自定义注解,执行在运行阶段,该注解用于修饰方法
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation {
String name();
int age() default 20;
String phone();
}
在Person类中的方法里使用自定义注解,并设置初始值
public class Person {
@MyAnnotation(name = "小王",age = 25,phone = "110")
public void getInfo() {
}
public static void getAnnoValue() {
try {
MyAnnotation myAnnotation = Person.class.getMethod("getInfo").getAnnotation(MyAnnotation.class);
System.out.println(myAnnotation.name() + " " + myAnnotation.age() + " " + myAnnotation.phone());
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
}
}
使用反射操作注解实战
定义一个注解的注解,再定义一个能用在各种元素上的注解
/**
* 定义target是注解的注解
*/
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
@interface AnnoTest {
String value() default "anno";
}
/**
* 定义一个几乎全量信息的注解
*/
@AnnoTest("annotest")
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE_USE, ElementType.FIELD, ElementType.TYPE, ElementType.METHOD,
ElementType.PACKAGE, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE})
@Documented
@interface FullAnnoTest {
String value() default "FullAnnoTest";
}
测试类和反射代码:在各种元素前添加FullAnnoTest注解和对应的value值,然后通过反射获取各处的注解value。
class ParentObj {
}
@FullAnnoTest("class")
public class TestAnnoReflect<@FullAnnoTest("parameter") T> extends @FullAnnoTest("parent") ParentObj {
//注解字段域
private @FullAnnoTest("name") String name;
//注解泛型字段域
private @FullAnnoTest("value") T value;
//注解通配符
private @FullAnnoTest("list") List<@FullAnnoTest("generic") ?> list;
@FullAnnoTest("constructor")
public TestAnnoReflect() {
}
//注解方法
@FullAnnoTest("method") //注解方法参数
public String hello(@FullAnnoTest("methodParameter") String name) throws @FullAnnoTest("Exception") Exception { //注解异常抛出
//注解局部变量
@FullAnnoTest("result") String result;
result = "result";
System.out.println(result);
return result;
}
@RequiresApi(api = Build.VERSION_CODES.O)
public static void testAnnotation() throws NoSuchMethodException {
TestAnnoReflect<String> testAnnoReflect = new TestAnnoReflect<>();
Class<TestAnnoReflect<Object>> clazz = (Class<TestAnnoReflect<Object>>) testAnnoReflect.getClass();
FullAnnoTest annotation;
Field[] fields = clazz.getDeclaredFields();
Annotation[] annotations = clazz.getAnnotations();
//获取class的注解
annotation = (FullAnnoTest)annotations[0];
System.out.println("修饰TestAnnoReflect类的注解value: " + annotation.value());
//获取构造器的 注解
Constructor<TestAnnoReflect<Object>> constructor = (Constructor<TestAnnoReflect<Object>>) clazz.getDeclaredConstructors()[0];
annotation = constructor.getAnnotation(FullAnnoTest.class);
System.out.println("构造器的注解value: " + annotation.value());
//获取注解的 注解
Class<? extends Annotation> annotationType = annotation.annotationType();
AnnoTest annoTest = annotationType.getAnnotation(AnnoTest.class);
System.out.println("修饰注解的注解AnnoTest-value: " + annoTest.value());
//获取方法的 注解
Method method = clazz.getDeclaredMethod("hello", String.class);
annotation = method.getAnnotation(FullAnnoTest.class);
System.out.println("修饰方法的注解value: " + annotation.value());
//获取方法参数的 注解
Parameter parameter = method.getParameters()[0];
annotation = parameter.getAnnotation(FullAnnoTest.class);
System.out.println("方法参数的注解value: " + annotation.value());
//获取方法抛出的异常上的 注解
Class<?>[] exceptionTypes = method.getExceptionTypes();
for (Class<?> exceptionType: exceptionTypes) {
annotation = exceptionType.getAnnotation(FullAnnoTest.class);
if (annotation != null) {
System.out.println("方法抛出的异常上的注解value: " + annotation.value());
}
}
//获取包的 注解
Package p = Package.getPackage("com.example.genericannotaionreflect.annotate");
annotation = p.getAnnotation(FullAnnoTest.class);
if (annotation != null) {
System.out.println("修饰package的注解value: " + annotation.value());
}
//获取各个属性的注解 和 属性类型的通配符注解,即 List<@FullAnnoTest("generic") ?>的注解
for (Field field : fields) {
FullAnnoTest fieldAnnotation = field.getAnnotation(FullAnnoTest.class);
if (fieldAnnotation != null) {
System.out.println("Field " + field.getName() + " Annotation Value: " + fieldAnnotation.value());
// 获取字段的泛型类型
Type genericType = field.getGenericType();
if (genericType instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) genericType;
// 获取泛型参数的实际类型
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
for (Type typeArgument : actualTypeArguments) {
if (typeArgument instanceof Class) {
Class<?> genericClass = (Class<?>) typeArgument;
// 获取泛型参数上的注解
FullAnnoTest genericAnnotation = genericClass.getAnnotation(FullAnnoTest.class);
if (genericAnnotation != null) {
System.out.println("Generic Type Annotation Value: " + genericAnnotation.value());
}
}
}
}
}
}
}
}
打印:
修饰TestAnnoReflect类的注解value: class
构造器的注解value: constructor
修饰注解的注解AnnoTest-value: annotest
修饰方法的注解value: method
方法参数的注解value: methodParameter
Field list Annotation Value: list
Field name Annotation Value: name
Field value Annotation Value: value
Generic Type Annotation Value: generic
其中用到field的泛型获取技术:
field.getGenericType()方法:
getGenericType()是Field接口的一个方法,它返回一个Type对象,表示字段的通用类型,包括泛型信息。
可能是Class、ParameterizedType、GenericArrayType等,例如List<String> list,list属性的getGenericType()得到的是List<String>类型的Type。
Class类型 表示普通类型
ParameterizedType 表示一个参数化类型,即带有实际类型参数的泛型类型。 对于 List<String>,Map<Integer, String> 等,它们都属于 ParameterizedType。
GenericArrayType 表示数组类型,其中的元素类型是参数化类型或者是类型变量。对于 List<String>[] 或者 T[](其中 T 是类型变量),它们都属于 GenericArrayType。
getActualTypeArguments()方法
是ParameterizedType接口的一个方法,用于获取泛型类型的实际类型参数。在Java中,泛型类型通常指的是参数化类型,比如List<String>,其中List是泛型类型,而String是它的实际类型参数,该方法返回的是数组。
-
使用注解来代替枚举类
虽然推荐使用枚举类替代一些int常量,但是在android中,官方还是不建议使用枚举类的:
Enums often require more than twice as much memory as static constants. You should strictly avoid using enums on Android.
由官网的描述可知,枚举类还是很耗费内存的,所以更加优雅的方式应该是使用注解的形式。官方使用两个注解类,IntDef和StringDef,用来提供枚举的替代方案。
class OrderState {
companion object {
//Android端制定订单状态,分别为全部,待支付, 待提货, 已完成, 已取消
const val ALL = 0
const val WAIT_PAY = 1
const val WAIT_DILIVERY = 2
const val COMPLETED = 3
const val CANCELLED = 4
/**
* 根据订单列表页获取订单页请求状态
*/
fun getOrderListStatus(@OrderState status: Int): Int = when (status) {
ALL ->
...
WAIT_PAY ->
...
WAIT_DILIVERY ->
...
COMPLETED ->
...
CANCELLED ->
...
else -> STATUS_ALL
}
}
@IntDef(ALL, WAIT_PAY, WAIT_DILIVERY, COMPLETED, CANCELLED)
@Retention(RetentionPolicy.SOURCE)
internal annotation class OrderState
}
注解的本质
public interface Annotation {
boolean equals(Object obj);
int hashCode();
String toString();
/**
* Returns the annotation type of this annotation.
* @return the annotation type of this annotation
*/
Class<? extends Annotation> annotationType();
}
注解本质上它是继承自Annotation的一个接口。但我们是可以通过反射拿到Annotation实例的,实际上,我们在运行期获取到的注解,都是接口的代理类。
注解的实际过程:
• 注解实质上会被编译器编译为接口,并且继承java.lang.annotation.Annotation接口。
• 注解的成员变量会被编译器编译为同名的抽象方法。
• 根据Java的class文件规范,class文件中会在程序元素的属性位置记录注解信息。
Kotlin注解与Java注解有什么不同?
Kotlin 的注解完全兼容 Java 的注解。
参考:
https://developer.aliyun.com/article/1114687