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
代码数据获取:【小型框架】
通过反射获取指定注解中的一些内容,例如:配置,数据,操作,验证等
@Override
重写/实现方法的情况下,检查方法声明是否和父类或者接口中的方法声明一致,强制格式检查
@Deprecated
标记当前方法已过时
@SuppressWarnings(“all”)
压制警告,可以用于一些代码中存在明确无异常的情况下,压制一些警告
Annotation注解属性【难点】
属性
开发实际使用注解的方式中,数据使用方式更加偏向于属性概念
使用
实际上是利用abstract方法来完成属性概念的
属性使用的格式【实际按照方法格式操作】
格式: 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个方法:
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直接进行替换
注解和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少依赖一个包,就造成那个逻辑并没有真的执行。这时从表面上也许很难看出来出错了。