java自定义注解
自定义注解
注解基础：
什么是注解？
对于很多初次接触的开发者来说应该都有这个疑问？
Annontation是Java5开始引入的新特征，中文名称叫注解。
它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。
为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且供指定的工具或框架使用。
Annontation像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。
Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。
注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。
注解的用处：
1、生成文档。这是最常见的，也是java 最早提供的注解。常用的有@param @return 等
2、跟踪代码依赖性，实现替代配置文件功能。比如Dagger 2 依赖注入，未来java 开发，将大量注解配置，具有很大用处;
3、在编译时进行格式检查。如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出。
4、配合反射完成一些功能，这才是核心
注解的原理：
注解本质是一个继承了Annotation 的特殊接口，其具体实现类是Java 运行时生成的动态代理类。
而我们通过反射获取注解时，返回的是Java 运行时生成的动态代理对象$Proxy1。
通过代理对象调用自定义注解（接口）的方法，会最终调用AnnotationInvocationHandler的invoke方法。
该方法会从memberValues这个Map 中索引出对应的值。
而memberValues 的来源是Java 常量池。
元注解：
java.lang.annotation 提供了四种元注解，专门注解其他的注解（在自定义注解的时候，需要使用到元注解）：
@Documented – 注解是否将包含在JavaDoc中 一般直接写上 类似于说明
@Retention – 什么时候使用该注解 何时？
@Target – 注解用于什么地方 何地？
@Inherited – 是否允许子类继承该注解 一般不用…
具体属性值：
1.）@Retention – 定义该注解的生命周期
● RetentionPolicy.SOURCE : 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注解。
● RetentionPolicy.CLASS : 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式
● RetentionPolicy.RUNTIME : 始终不会丢弃，运行期也保留该注解，因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。
2.）Target – 表示该注解用于什么地方。默认值为任何元素，表示该注解用于什么地方。可用的ElementType 参数包括
● ElementType.CONSTRUCTOR: 用于描述构造器
● ElementType.FIELD: 成员变量、对象、属性（包括enum实例）
● ElementType.LOCAL_VARIABLE: 用于描述局部变量
● ElementType.METHOD: 用于描述方法
● ElementType.PACKAGE: 用于描述包
● ElementType.PARAMETER: 用于描述参数
● ElementType.TYPE: 用于描述类、接口(包括注解类型) 或enum声明
3.)@Documented – 一个简单的Annotations 标记注解，表示是否将注解信息添加在java 文档中。
4.)@Inherited – 定义该注释和子类的关系
@Inherited 元注解是一个标记注解，@Inherited 阐述了某个被标注的类型是被继承的。
如果一个使用了@Inherited 修饰的annotation 类型被用于一个class，则这个annotation 将被用于该class 的子类。
常见标准的Annotation：
1.）Override
java.lang.Override 是一个标记类型注解，它被用作标注方法。它说明了被标注的方法重写了父类的方法，起到了断言的作用。如果我们使用了这种注解在一个没有覆盖父类方法的方法时，java 编译器将以一个编译错误来警示。
2.）Deprecated
Deprecated 也是一种标记类型注解。当一个类型或者类型成员使用@Deprecated 修饰的话，编译器将不鼓励使用这个被标注的程序元素。所以使用这种修饰具有一定的“延续性”：如果我们在代码中通过继承或者覆盖的方式使用了这个过时的类型或者成员，虽然继承或者覆盖后的类型或者成员并不是被声明为@Deprecated，但编译器仍然要报警。
3.）SuppressWarnings
SuppressWarning 不是一个标记类型注解。它有一个类型为String[] 的成员，这个成员的值为被禁止的警告名。对于javac 编译器来讲，被-Xlint 选项有效的警告名也同样对@SuppressWarings 有效，同时编译器忽略掉无法识别的警告名。
@SuppressWarnings(“unchecked”)
自定义注解：
自定义注解类编写的一些规则:
- Annotation 型定义为@interface, 所有的Annotation 会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口.
- 参数成员只能用public 或默认(default) 这两个访问权修饰 默认是value() 可以省略
- 参数成员只能用基本类型byte、short、char、int、long、float、double、boolean八种基本数据类型和String、Enum、Class、annotations等数据类型，以及这一些类型的数组.
- 要获取类方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation 对象，因为你除此之外没有别的获取注解对象的方法
- 注解也可以没有定义成员，不过这样注解就没啥用了
6.自定义注解需要使用到元注解否则无法确认哪里 何时
创建一个实用类
public class Apple {
@FruitName("红富士")
private String appleName;//苹果名称
@FruitColor(frutiColor = FruitColor.Color.YELLOW)
private String appleColor;//苹果颜色
@FruitProvider(id=999,name="陕西红富士",address="陕西")
private String appleProvider;//生产厂商
@AAA(appleProvider = "厂商aaa",appleColor = "黄色",appleName = "个崩碎")
public Apple(){}
public Apple(String appleName, String appleColor, String appleProvider) {
this.appleName = appleName;
this.appleColor = appleColor;
this.appleProvider = appleProvider;
}
public String getAppleName() {
return appleName;
}
public void setAppleName(String appleName) {
this.appleName = appleName;
}
public String getAppleColor() {
return appleColor;
}
public void setAppleColor(String appleColor) {
this.appleColor = appleColor;
}
public String getAppleProvider() {
return appleProvider;
}
public void setAppleProvider(String appleProvider) {
this.appleProvider = appleProvider;
}
@Override
public String toString() {
return "Apple{" +
"appleName='" + appleName + '\'' +
", appleColor='" + appleColor + '\'' +
", appleProvider='" + appleProvider + '\'' +
'}';
}
}
@interface水果颜色
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FruitColor {
enum Color{
BLUE,RED,GREEN,YELLOW
}
Color frutiColor() default Color.RED;
}
水果名字
@Documented//记录
@Target(ElementType.FIELD)//目标 元素类型字段 这个注解 可以定义在 属性（变量）上 何地
@Retention(RetentionPolicy.RUNTIME)//保留 保留策略运行时
public @interface FruitName {
String value() default "";
}
水果厂商
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FruitProvider {
/*
供应商编号
*/
int id() default -1;
/*
生产厂商
*/
String name() default "";
/*
生产厂商地址
*/
String address() default "";
}
**自定义注解**
@Target(ElementType.CONSTRUCTOR)
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface AAA {
String appleName()default "";
String appleColor() default "";
String appleProvider() default "";
}
通过反射获取属性，改造方法实例对象
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
//注解处理器 没有这个处理器 定义的注解 不能生效
public class FruitInfoUtil {
public static void getInfo(Class<?>clazz){
String strFruitName = "水果名称:";
String strFruitColor = "水果颜色:";
String strFruitProvider = "生产厂商:";
//通过反射获取属性信息
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
//看你哪个字段上 有Anno
if (field.isAnnotationPresent(FruitName.class)){//FruitName的注解是否在field上 如果在true 不在返回false
//获取某一个方法上的某个注解，要是没有该注解则返回null，有的话就返回该注解的类型
FruitName annotaion=field.getAnnotation(FruitName.class);
strFruitName=strFruitName+annotaion.value();
}
else if (field.isAnnotationPresent(FruitColor.class)){
FruitColor annotation = field.getAnnotation(FruitColor.class);
strFruitColor=strFruitColor+annotation.frutiColor().toString();
}
else if (field.isAnnotationPresent(FruitProvider.class)){
FruitProvider annotation=field.getAnnotation(FruitProvider.class);
strFruitProvider=strFruitProvider+annotation.name()+",id"+annotation.id()+"地址"+annotation.address();
}
}
System.out.println(strFruitName+"\n"+strFruitColor+"\n"+strFruitProvider);
System.out.println("================");
}
// 改造方法 获取实例对象 （带属性）
public static void print(Class<?> clazz) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
if (declaredConstructor.isAnnotationPresent(AAA.class)){
//获取某一个方法上的某个注解，要是没有该注解则返回null，有的话就返回该注解的类型
AAA annotation = declaredConstructor.getAnnotation(AAA.class);
String color = annotation.appleColor();
String name = annotation.appleName();
String provider = annotation.appleProvider();
Apple o = (Apple) declaredConstructor.newInstance();
Method setAppleName = clazz.getMethod("setAppleName",String.class);
setAppleName.invoke(o,name);
Method setAppleColor = clazz.getMethod("setAppleColor",String.class);
setAppleColor.invoke(o,color);
Method setAppleProvider = clazz.getMethod("setAppleProvider", String.class);
setAppleProvider.invoke(o,provider);
System.out.println(o);
}
}
}
//
public static <T>T getInstance(Class<T>clazz) throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//通过反射获取属性信息
Field[] fields = clazz.getDeclaredFields();
T o = (T)clazz.newInstance();
for (Field field : fields) {
//看你哪个字段上 有Anno
if (field.isAnnotationPresent(FruitName.class)){
FruitName annotation = field.getAnnotation(FruitName.class);
String value=annotation.value();
String name = field.getName();
//用于把字符串转换为大写
name =name.toUpperCase().substring(0,1)+ name.substring(1,name.length());
System.out.println(name);
Method method = clazz.getMethod("set" +name, field.getType());//appleName => setAppleName
method.invoke(o,value);
}else if (field.isAnnotationPresent(FruitColor.class)){
FruitColor annotation = field.getAnnotation(FruitColor.class);
FruitColor.Color s = annotation.frutiColor();
String color = s.toString();
String name = field.getName();
name =name.toUpperCase().substring(0,1)+ name.substring(1,name.length());
System.out.println(name);
Method method = clazz.getMethod("set" + name, field.getType());//appleName => setAppleName
method.invoke(o,color);
}
else if (field.isAnnotationPresent(FruitProvider.class)){
FruitProvider annotation = field.getAnnotation(FruitProvider.class);
int id = annotation.id();
String pname = annotation.name();
String address = annotation.address();
String x=id+"--"+pname+"--"+address;
String name = field.getName();
name =name.toUpperCase().substring(0,1)+ name.substring(1,name.length());
System.out.println(name);
Method method = clazz.getMethod("set" + name, field.getType());//appleName => setAppleName
method.invoke(o,x);
}
}
return o;
}
}
调用方法
public class Test {
public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
//打印内容
FruitInfoUtil.getInfo(Apple.class);
Apple a=new Apple();
System.out.println(a);
System.out.println("===========");
FruitInfoUtil.print(Apple.class);
System.out.println("============");
Apple instance = FruitInfoUtil.getInstance(Apple.class);
System.out.println(instance);
}
}
输出结果
水果名称:红富士
水果颜色:YELLOW
生产厂商:陕西红富士,id999地址陕西
================
Apple{appleName='null', appleColor='null', appleProvider='null'}
===========
Apple{appleName='个崩碎', appleColor='黄色', appleProvider='厂商aaa'}
============
AppleName
AppleColor
AppleProvider
Apple{appleName='红富士', appleColor='YELLOW', appleProvider='999--陕西红富士--陕西'}
Process finished with exit code 0