您的位置：360文档中心› Java实战篇：设计自己的Annotation【达内科技java培训】

Java实战篇：设计自己的Annotation【达内科技java培训】

合集下载

Java Annotation 入门

Java Annotation 入门

Java Annotation 入门[关于Annotation 的翻译]这是语言学家需要做的事，但考虑到语言学家对这个领域不太关注。

还是自己先分析一下吧。

英文中的Comment 和Annotation 对应的中文翻译都是“注释、注解”,但个人感觉，Comment 更适合翻译成“注释”不仅因为已经广泛使用的，而且从意义上说，更接近。

个人以为，“Annotation”更接近“标记”这个含义，但是，XML 技术已经把“Markup”赋予这个词并广泛使用。

另一个“Annotation”接近的词是“Description”，描述或者说明。

但感觉这个词太泛泛。

想来想去，还是用原词吧！[历史]Java 平台原来就有一些类似Annotation 的机制，例如，Java 关键字transient 告诉Java 运行环境，持久化这个类时，这个变量是个例外。

javadoc标记@deprecated 告诉Java 编译器和运行时一旦有谁使用了这个API，你要报一个警告。

JCP 组织早在2002 年就把Annotation (被称为metadata) 作为JSR 175 引入了，并在2004 年9 月批准。

在Java 语言第三版中，正式加入了这个语言新特性的支持，并在JDK 1.5 发布。

在JDK 1.5 中，临时性的引入了apt 这个工具提供编译时的相关处理。

随后，JSR 269 标准化了Annotation 的处理过程，定义了一套annotation 处理API。

并在JDK 1.6 的javac编译器中集成了这个功能。

[什么是Annotation]情况1：我们在编写某些应用时，需要编写一组固定模式的代码，例如，JAX-RPC web 服务，你必须提供一个接口定义和一个与之对应的实现类（的框架）。

情况2：我们在开发EJB 时，除了要编写EJB 的接口代码和实现代码，还要编写与之配套的XML 格式的描述文件。

无论情况1中的接口和实现类的匹配使用，还是情况2中的代码和描述的配合使用，手工的方式是低效和容易出错的，不易维护。

JavaAnnotation使用大全

JavaAnnotation使用大全

Java Annotation使用大全一、Annotation究竟是什么？Annotation 提供了一条与程序元素关联任何信息或者任何元数据（metadata）的途径。

从某些方面看，annotation就像修饰符一样被使用，并应用于包、类型、构造方法、方法、成员变量、参数、本地变量的声明中。

这些信息被存储在annotation的“name=value”结构对中。

annotation类型是一种接口，能够通过java反射API的方式提供对其信息的访问。

annotation能被用来为某个程序元素（类、方法、成员变量等）关联任何的信息。

需要注意的是，这里存在着一个基本的潜规则：annotaion不能影响程序代码的执行，无论增加、删除annotation，代码都始终如一的执行。

另外，尽管一些annotation通过java的反射api方法在运行时被访问，而java语言解释器在工作时忽略了这些annotation。

正是由于java虚拟机忽略了annotation，导致了annotation类型在代码中是“不起作用”的；只有通过某种配套的工具才会对annotation类型中的信息进行访问和处理。

本文中将涵盖标准的annotation和meta- annotation类型，陪伴这些annotation类型的工具是java编译器（当然要以某种特殊的方式处理它们）。

由于上述原因，annotation在使用时十分简便。

一个本地变量可以被一个以NonNull命名的annotation类型所标注，来作为对这个本地变量不能被赋予null值的断言。

而我们可以编写与之配套的一个annotation代码分析工具，使用它来对具有前面变量的代码进行解析，并且尝试验证这个断言。

当然这些代码并不必自己编写。

在JDK安装后，在JDK/bin目录中可以找到名为“apt”的工具，它提供了处理annotation的框架：它启动后扫描源代码中的annotation，并调用我们定义好的annotation处理器完成我们所要完成的工作（比如验证前面例子中的断言）。

Java中的注解（Annotation）

Java中的注解（Annotation）

Java中的注解（Annotation）⽬录结构：contents structure [+]1.2.3.1.2.4.1.2.1.什么是注解⽤⼀个词就可以描述注解，那就是元数据，即⼀种描述数据的数据。

所以，可以说注解就是源代码的元数据。

⽐如，下⾯这段代码：@Overridepublic String toString() {return "This is String Representation of current object.";}上⾯的代码中，我重写了toString()⽅法并使⽤了@Override注解。

但是，即使我不使⽤@Override注解标记代码，程序也能够正常执⾏。

那么，该注解表⽰什么？这么写有什么好处吗？事实上，@Override告诉编译器这个⽅法是⼀个重写⽅法(描述⽅法的元数据)，如果⽗类中不存在该⽅法，编译器便会报错，提⽰该⽅法没有重写⽗类中的⽅法。

如果我不⼩⼼拼写错误，例如将toString()写成了toStrring(){double r}，⽽且我也没有使⽤@Override注解，那程序依然能编译运⾏。

但运⾏结果会和我期望的⼤不相同。

现在我们了解了什么是注解，并且使⽤注解有助于阅读程序。

Annotation是⼀种应⽤于类、⽅法、参数、变量、构造器及包声明中的特殊修饰符。

它是⼀种由JSR-175标准选择⽤来描述元数据的⼀种⼯具。

2.为什么要使⽤注解使⽤Annotation之前(甚⾄在使⽤之后)，XML被⼴泛的应⽤于描述元数据。

不知何时开始⼀些应⽤开发⼈员和架构师发现XML的维护越来越糟糕了。

他们希望使⽤⼀些和代码紧耦合的东西，⽽不是像XML那样和代码是松耦合的(在某些情况下甚⾄是完全分离的)代码描述。

假如你想为应⽤设置很多的常量或参数，这种情况下，XML是⼀个很好的选择，因为它不会同特定的代码相连。

如果你想把某个⽅法声明为服务，那么使⽤Annotation会更好⼀些，因为这种情况下需要注解和⽅法紧密耦合起来，开发⼈员也必须认识到这点。

annotation入门实例

annotation入门实例

Annotation在java的世界正铺天盖地展开,有空写这一篇简单的annotations的文章,算是关于Annotation入门的文章吧,希望能各位们能抛砖,共同学习......不讲废话了,实践才是硬道理.第一部分:了解一下java1.5起默认的三个annotation类型:一个是@Override:只能用在方法之上的，用来告诉别人这一个方法是改写父类的。

一个是@Deprecated:建议别人不要使用旧的API的时候用的,编译的时候会用产生警告信息,可以设定在程序里的所有的元素上.一个是@SuppressWarnings:这一个类型可以来暂时把一些警告信息消息关闭.如果不清楚上面三个类型的具体用法，各位可以baidu或google一下的,很简单的。

第二部分:讲一下annotation的概念先，再来讲一下怎样设计自己的annotation.首先在jdk自带的ng.annotation包里,打开如下几个源文件:1、源文件Target.javaJava代码@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.ANNOTATION_TYPE)public @interface Target {ElementType[] value();}@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.ANNOTATION_TYPE)public @interface Target {ElementType[] value();}其中的@interface是一个关键字，在设计annotations的时候必须把一个类型定义为@interface，而不能用class或interface关键字(会不会觉得sun有点吝啬,偏偏搞得与interface这么像).2、源文件Retention.javaJava代码@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.ANNOTATION_TYPE)public @interface Retention {RetentionPolicy value();}@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.ANNOTATION_TYPE)public @interface Retention {RetentionPolicy value();}看到这里，大家可能都模糊了,都不知道在说什么，别急，往下看一下.在上面的文件都用到了RetentionPolicy，ElementType这两个字段,你可能就会猜到这是两个java文件.的确，这两个文件的源代码如下：3、源文件RetentionPolicy.javaJava代码public enum RetentionPolicy {SOURCE,CLASS,RUNTIME}public enum RetentionPolicy {SOURCE,CLASS,RUNTIME}这是一个enum类型,共有三个值，分别是SOURCE,CLASS 和 RUNTIME.SOURCE代表的是这个Annotation类型的信息只会保留在程序源码里，源码如果经过了编译之后，Annotation的数据就会消失,并不会保留在编译好的.class文件里面。

java中annotation注释方法

java中annotation注释方法

在Java中，注解（Annotation）是一种特殊的修饰符，它可以用于为代码提供元数据。

注解可以用于类、方法、字段等各种程序元素上。

要在Java方法上使用注解，需要按照以下步骤进行操作：1. 定义注解：首先，你需要定义一个注解，使用`@interface`关键字来表示。

注解可以包含成员变量，成员变量可以设置默认值，也可以使用`default`关键字指定。

例如：```javapublic @interface MyAnnotation {String value() default "";int count() default 0;}```2. 使用注解：在需要使用注解的方法上，使用`@注解名`的方式进行标记。

可以在注解中设置对应的属性值。

例如：```java@MyAnnotation(value = "Hello World", count = 10)public void myMethod() {// 方法实现}```3. 获取注解信息：通过反射机制，可以在运行时获取方法上的注解信息。

例如：```java// 获取方法上的注解MyAnnotation annotation = myMethod.getClass().getAnnotation(MyAnnotation.class);// 获取注解的属性值String value = annotation.value();int count = annotation.count();```需要注意的是，注解在Java中并不会对程序的执行产生直接影响，它只是用于提供额外的元数据信息。

在实际开发中，你可以利用注解完成一些自动化的操作，如代码生成、配置读取等。

Java注解Annotation与自定义注解详解

Java注解Annotation与自定义注解详解

Java注解Annotation与⾃定义注解详解⼀：Java注解简介开发中经常使⽤到注解，在项⽬中也偶尔会见到过⾃定义注解，今天就来探讨⼀下这个注解是什么⿁，以及注解的应⽤场景和如何⾃定义注解。

下⾯列举开发中常见的注解@Override：⽤于标识该⽅法继承⾃超类, 当⽗类的⽅法被删除或修改了，编译器会提⽰错误信息(我们最经常看到的toString()⽅法上总能看到这货)@Deprecated：表⽰该类或者该⽅法已经不推荐使⽤，已经过期了，如果⽤户还是要使⽤，会⽣成编译的警告@SuppressWarnings：⽤于忽略的编译器警告信息Junit测试：@TestSpring的⼀些注解：@Controller、@RequestMapping、@RequestParam、@ResponseBody、@Service、@Component、@Repository、@Resource、@AutowireJava验证的注解：@NotNull、@Email下⾯看⼀下注解Override.java的庐⼭真⾯⽬@Target(ElementType.METHOD)@Retention(RetentionPolicy.SOURCE)public @interface Override {}⼆：Java注解基本知识1. Java注解数据类型注解是写在.java⽂件中，使⽤@interface作为关键字, 所以注解也是Java的⼀种数据类型，从⼴泛的定义来说，Class、Interface、Enum、Annotation都属于Class类型。

2. Java元注解在创建注解的时候，需要使⽤⼀些注解来描述⾃⼰创建的注解，就是写在@interface上⾯的那些注解，这些注解被称为元注解，如在Override中看到的@Target、@Retention等。

下⾯列出⼀些元注解@Documented: ⽤于标记在⽣成javadoc时是否将注解包含进去，可以看到这个注解和@Override⼀样，注解中空空如也，什么东西都没有@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.ANNOTATION_TYPE)public @interface Documented {}@Target：⽤于定义注解可以在什么地⽅使⽤，默认可以在任何地⽅使⽤，也可以指定使⽤的范围，开发中将注解⽤在类上(如@Controller)、字段上(如@Autowire)、⽅法上(如@RequestMapping)、⽅法的参数上(如@RequestParam)等⽐较常见。

Java基础之Annotation解读

Java基础之Annotation解读

Java基础之理解Annotation一、概念Annontation是Java5开始引入的新特征。

中文名称一般叫注解。

它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。

更通俗的意思是为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且是供指定的工具或框架使用的。

Annontation像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。

二、原理Annotation其实是一种接口。

通过Java的反射机制相关的API来访问annotation信息。

相关类（框架或工具中的类）根据这些信息来决定如何使用该程序元素或改变它们的行为。

annotation是不会影响程序代码的执行，无论annotation怎么变化，代码都始终如一地执行。

Java语言解释器在工作时会忽略这些annotation，因此在JVM 中这些annotation是“不起作用”的，只能通过配套的工具才能对这些annontaion类型的信息进行访问和处理。

Annotation与interface的异同：1）、Annotation类型使用关键字@interface而不是interface。

这个关键字声明隐含了一个信息：它是继承了ng.annotation.Annotation接口，并非声明了一个interface2）、Annotation类型、方法定义是独特的、受限制的。

Annotation 类型的方法必须声明为无参数、无异常抛出的。

这些方法定义了annotation的成员：方法名成为了成员名，而方法返回值成为了成员的类型。

而方法返回值类型必须为primitive 类型、Class类型、枚举类型、annotation类型或者由前面类型之一作为元素的一维数组。

方法的后面可以使用default和一个默认数值来声明成员的默认值，null不能作为成员默认值，这与我们在非annotation类型中定义方法有很大不同。

java教程笔记11--Annotation

java教程笔记11--Annotation

java学习笔记11--AnnotationAnnotation：在JDK1.5之后增加的一个新特性，这种特性被称为元数据特性，在JDK1.5之后称为注释，即：使用注释的方式加入一些程序的信息。

ng.annotation Annotation接口是所有的Annotation都必须实现的接口。

系统内建的Annotation在JDK1.5之后，系统中已经建立了如下的三个内建的Annotation类型，用户直接使用即可。

@Override：覆写的Annotation@Deprecated：不赞成使用的Annotation@SuppressWarnings：压制安全警告的Annotation自定义AnnotationAnnotation定义格式：【public】@interface Annotation名称{数据类型变量名称();}public @interface Meaning {String value();}之后就直接可以在程序中使用@Meaning的格式@Meaning(value="itmyhome")class Demo{}可以在Annotation中设置一个参数，用来接收变量的内容，如上面的value，使用Annotation的时候也必须给参数赋值如：value="itmyhome"既然可以设置一个参数，则同时也就可以设置多个参数。

public @interface Meaning {String key();String value();}之后就直接可以在程序中使用@Meaning的格式@Meaning(value="itmyhome")class Demo{}可以在Annotation中设置一个参数，用来接收变量的内容，如上面的value，使用Annotation的时候也必须给参数赋值如：value="itmyhome"既然可以设置一个参数，则同时也就可以设置多个参数。

Java注解（Annotations）详解

Java注解（Annotations）详解

Java注解（Annotations）详解注解是元数据注解是⼀种装饰器、⼀个标记(maker)，应⽤于Java的各种结构之上，例如类、⽅法、字段。

⽤来为这些结构绑定元数据。

注解不包含任何业务逻辑。

只由运⾏时框架或编译器根据注解信息去执⾏具体⾏为。

Retention and Target保留（Retention ）策略指定就程序⽣命周期⽽⾔，注释应该保留多长时间（⼀个）⽬标（Target）指定注解可以应⽤于哪些Java结构（多个）⾃定义annotation@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.FIELD)public @interface JsonField {public String value() default "";}public class Car {@JsonField("manufacturer")private final String make;@JsonFieldprivate final String model;private final String year;public Car(String make, String model, String year) {this.make = make;this.model = model;this.year = year;}## get and set method@Overridepublic String toString() {return year + " " + make + " " + model;}}利⽤反射机制执⾏具体⾏为public class JsonSerializer {public String serialize(Object object) throws JsonSerializeException {try {Class<?> objectClass = requireNonNull(object).getClass();Map<String, String> jsonElements = new HashMap<>();for (Field field: objectClass.getDeclaredFields()) {field.setAccessible(true);if (field.isAnnotationPresent(JsonField.class)) {jsonElements.put(getSerializedKey(field), (String)field.get(object));}}System.out.println(toJsonString(jsonElements));return toJsonString(jsonElements);} catch (IllegalAccessException e) {throw new JsonSerializeException(e.getMessage());}}private String toJsonString(Map<String, String> jsonMap) {String elementsString = jsonMap.entrySet().stream().map(entry -> "\"" + entry.getKey() + "\":\"" + entry.getValue() + "\"").collect(Collectors.joining(","));return "{" + elementsString + "}";}private String getSerializedKey(Field field) {String annotationValue = field.getAnnotation(JsonField.class).value();if (annotationValue.isEmpty()) {return field.getName();} else {return annotationValue;}}}Car car = new Car("Ford", "F150", "2018");JsonSerializer serializer = new JsonSerializer();serializer.serialize(car);# output# {"model":"F150","manufacturer":"Ford"}总结虽然注解不应该⽤来代替接⼝或其他以⾯向对象的⽅式正确完成任务的语⾔结构，但它们可以极⼤地简化重复的逻辑。

java自定义注解Annotation

java自定义注解Annotation

java自定义Annotationjava中自定义annotation需要@interface关键字和用到几个内置annotation。

用到的注解有@Target,@Retention,@Documented,@Inherited ，用途如下：@Target 表示该注解用于什么地方，可能的ElemenetType 参数包括：ElemenetType.CONSTRUCTOR 构造器声明ElemenetType.FIELD 域声明（包括enum 实例）ElemenetType.LOCAL_VARIABLE 局部变量声明ElemenetType.METHOD 方法声明ElemenetType.PACKAGE 包声明ElemenetType.PARAMETER 参数声明ElemenetType.TYPE 类，接口（包括注解类型）或enum声明@Retention 表示在什么级别保存该注解信息。

可选的RetentionPolicy 参数包括：RetentionPolicy.SOURCE 注解将被编译器丢弃RetentionPolicy.CLASS 注解在class文件中可用，但会被VM丢弃RetentionPolicy.RUNTIME VM将在运行期也保留注释，因此可以通过反射机制读取注解的信息。

@Documented 将此注解包含在javadoc 中@Inherited 允许子类继承父类中的注解@Documented的目的就是让这一个Annotation类型的信息能够显示在javaAPI说明文档上;没有添加的话，使用javadoc生成API文档的时候就会找不到这一个类型生成的信息.另外一点，如果需要把Annotation的数据继承给子类，那么就会用到@Inherited这一个。

下面自定义两个简单的annatation。

package annotation;import ng.annotation.Documented;import ng.annotation.ElementType;import ng.annotation.Retention;import ng.annotation.RetentionPolicy;import ng.annotation.Target;@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface Description {String value() default "no description";}////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////package annotation;import ng.annotation.Documented;import ng.annotation.ElementType;import ng.annotation.Retention;import ng.annotation.RetentionPolicy;import ng.annotation.Target;@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface Name {String originate();String community();}////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////package annotation;@Description("javaeye, to be best")public class JavaEyer {@Name(originate = "创始人:robbin", community = "javaeye")public String getEyeName() {return null;}@Name(originate = "创始人:江南白衣", community = "springside")public String getSideName() {return "excuse me";}}////////////////////////////////////////////////////////////////////////////测试类///////////////////////////////////////////////////////////////////////////package annotation;import ng.reflect.Method;import java.util.HashSet;import java.util.Set;public class AnnotationTest {@SuppressWarnings("unchecked")public static void main(String[] args) throws ClassNotFoundException { final String CLASS_NAME = "annotation.JavaEyer";Class test = Class.forName(CLASS_NAME);Method[] methods = test.getMethods();boolean flag = test.isAnnotationPresent(Description.class);if (flag) {Description des = (Description) test.getAnnotation(Description.class);System.out.println("描述:" + des.value());System.out.println("-----------------");}Set<Method> set = new HashSet<Method>();for (int i = 0; i < methods.length; i++) {boolean otherflag = methods[i].isAnnotationPresent(Name.class);if (otherflag) {set.add(methods[i]);}}for (Method method : set) {Name name = method.getAnnotation(Name.class);System.out.println(name.originate());System.out.println("创建的社区:" + munity());}}}。

自定义注解Annotation

自定义注解Annotation

以通过default来声明参数的默认值。

定义注解格式：public @interface 注解名{定义体}注解参数的可支持数据类型：1.所有基本数据类型（int,float,boolean,byte,double,char,long,short)2.String类型3.Class类型4.enum类型5.Annotation类型6.以上所有类型的数组Annotation类型里面的参数该怎么设定:第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型；第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String;第三,如果只有一个参数成员,最好把参数名称设为"value",后加小括号.例:下面的例子FruitName注解就只有一个参数成员。

简单的自定义注解和使用注解实例：package annotation;import ng.annotation.Documented;import ng.annotation.ElementType;import ng.annotation.Retention;import ng.annotation.RetentionPolicy;import ng.annotation.Target;/*** 水果名称注解* @author peida**/@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface FruitName {String value() default "";}package annotation;import ng.annotation.Documented; import ng.annotation.ElementType; import ng.annotation.Retention; import ng.annotation.RetentionPolicy; import ng.annotation.Target;/*** 水果颜色注解* @author peida**/@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface FruitColor {/*** 颜色枚举* @author peida**/public enum Color{ BULE,RED,GREEN};/*** 颜色属性* @return*/Color fruitColor() default Color.GREEN;}package annotation;import annotation.FruitColor.Color;public class Apple {@FruitName("Apple")private String appleName;@FruitColor(fruitColor=Color.RED)private String appleColor;public void setAppleColor(String appleColor) {this.appleColor = appleColor;}public String getAppleColor() {return appleColor;}public void setAppleName(String appleName) {this.appleName = appleName;}public String getAppleName() {return appleName;}public void displayName(){System.out.println("水果的名字是：苹果");}}注解元素的默认值：注解元素必须有确定的值，要么在定义注解的默认值中指定，要么在使用注解时指定，非基本类型的注解元素的值不可为null。

java annotation 数组写法

java annotation 数组写法

java annotation 数组写法Java Annotation是一种用于给Java类、方法、变量等元素添加元数据的工具，它可以被用来实现一些常见功能，如代码格式化、文档生成等。

在Java编程中，数组是一种常见的数据结构，可以通过使用注解（Annotation）来实现更加灵活的用法。

在Java中，数组可以用于表示多个注解的值。

以下是一个使用数组的注解的例子：```java@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.METHOD)public @interface MyAnnotation {String[] value() default "";}```上面的代码定义了一个名为`MyAnnotation`的注解，它的值是一个字符串数组。

默认情况下，该数组的值为空字符串。

这个注解可以在方法上使用，表示该方法需要满足某些条件。

例如：```javapublic class MyClass {@MyAnnotation(value = {"arg1", "arg2"})public void myMethod(String arg1, String arg2) {// method body}}```在上面的代码中，`myMethod`方法使用了`MyAnnotation`注解，指定了字符串数组`value`的值。

这表示该方法需要满足该注解所描述的条件，具体来说就是该方法需要接受两个字符串参数。

需要注意的是，使用数组作为注解的值时，数组中的每个元素都会被视为一个独立的值。

这意味着可以使用多个不同的值来描述同一个注解所描述的条件。

例如，上面的代码中使用了两个字符串参数来描述`MyAnnotation`注解所描述的条件。

除了使用数组之外，还可以使用其他数据结构来表示注解的值。

例如，可以使用一个Map来表示一组键值对或者一个List来表示一组对象。

夯实Java基础(十七)——注解(Annotation)

夯实Java基础(十七)——注解(Annotation)

夯实Java基础（十七）——注解(Annotation)夯实Java基础（十七）&mdash;&mdash;注解(Annotation)
1、注解概述
从JDK5.0开头，Java增强对元数据(MetaData)的支持，也就是注解(Annotation)。

其实我们早就已经接触过注解了，例如我们常常在Java代码中可以看到 @Override，@Test等等这样的东西，它们就是Java中的注解。

注解可以像修饰符一样用法，可以用于修饰包、类、构造器、办法、成员变量、参数、局部变量的声明。

我们需要注重的是，注解与注释是有一定区分的，注解就是代码里面的特别标志，这些标志可以在编译，类加载，运行时被读取，并执行相应的处理。

通过注解开发人员可以在不转变原有代码和规律的状况下在源代码中嵌入补充信息。

而注释则是用以解释某段代码的作用，或者解释某个类的用途、某个办法的功能和介绍，以及该办法的参数和返回值的数据类型及意义等等。

2、Java内置注解
在JavaSE部分，注解的用法往往比较容易，Java中提供了5个内置注解，它们分离是：
第1页共23页。

【黑马程序员】Java中的Annotation详解

【黑马程序员】Java中的Annotation详解

【黑马程序员】Java中的Annotation详解前言：作为Java开发人员，经常能在代码中看到注解（Annotation），有的是JAVA内置的注解，或者是在使用一些三方的开源框架的代码时候看到一些别人的自定义注解。

如果你对注解不了解或者不知道如何使用，那么你在用这些三方框架的时候甚至在自己写源码修改源码的时候就会变得更加的困难和举步维艰。

通过该篇文章可以基本的将注解Annotation的原理以及使用了解清楚，更加有利于你下一步比如使用Retrofit进行网络的开发打下基础。

1.概念官方的定义：An annotation is a form of metadata, that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated. Annotations have no direct effect on the operation of the code they annotate.注解Annotation是JDK5.0的新特性，是一种能够添加到Java 源代码的语法元数据。

类、方法、变量、参数、包都可以被注解，可用来将信息元数据与程序元素进行关联。

Annotation 中文常译为“注解”。

2.作用Annotations have a number of uses, among them:Information for the compiler —Annotations can be used by thecompiler to detect errors or suppress warnings.Compile-time and deployment-time processing —Software toolscan process annotation information to generate code, XML files,and so forth.Runtime processing —Some annotations are available to beexamined at runtime.a. 标记，用于告诉编译器一些信息b. 编译时动态处理，如动态生成代码c. 运行时动态处理，如得到注解信息Java注解可以用在构建期。

Java基础温习笔记12Java自概念注解Annotation的利用

Java基础温习笔记12Java自概念注解Annotation的利用

Java基础温习笔记12Java自概念注解Annotation的利用刘岩1.前言自以后，推出了注解新特性。

注解的推出其实最要紧的目的是为了让广大的用户认知，因为广受大多数开发者的诟骂和质疑。

为了减少配置、让注解替代配置。

有了注解，咱们以前看似一样的、一般的JavaBean就有了活力，有了内涵，有了新的契机。

配合Sun 的JPA标准，又再次在企业级开发中大放异彩，让很多开发者赞不绝口。

或许是无心插柳，这种“零配置”思维也阻碍着Java其他的开源项目——像Struts、Spring、Hibernate （也确实是咱们耳熟能详的SSH）不都是具有“零配置”支持嘛！Java此刻也是往动态、敏捷的方向进展着。

有可能以后配置文件愈来愈少、标准、约定、注解代替了繁琐的配置信息。

而XML估量会回归原始的使命——数据传输与数据互换。

2.自概念注解至于已有的注解，比如：JPA、EJB、Spring零配置等等怎么利用相信列位读者都能把握，那个地址主若是说如何自概念自己的注解，自己利用自概念的注解。

咱们先用一个简单的例子来看用关键字@interface概念一个注解标记，。

这句话代表的意思确实是在Test注解中能够含有属性名为isAop，此属性的类型是字符串类型。

客户端利用的时候能够依照需要自己指定相关的属性值。

若是客户端不指定值，默许值是false这句话代表着将利用该注解类的信息值维持到真正的客户端运行时环境。

下面咱们就来看看客户端的利用在客户端挪用中在类UseTest上利用了@Test(isAop = "true")注解。

仅仅概念了注解就像《三国杀》里，刘备是主公，他有“激将”的主公计，下了个命令：“蜀将安在？”，刘备的这句话太抽象了，蜀将相当于一个注解。

在场的所有蜀将就像加了此注解的类，都会受到这句话的阻碍。

具体替不替刘备出杀，~~~~个人表现不同（得先看看自己的身份啊）反贼的表现是：“那个真没有”；忠臣的表现是，先看看手上有杀吗？有，出击吧！没有就说：“那个……真没有！”；内奸的反映是：“唉，先保命仍是装一装忠臣？比较纠结！”。

详解Java如何创建Annotation

详解Java如何创建Annotation

详解Java如何创建Annotation前⾔注解是Java很强⼤的部分，但⼤多数时候我们倾向于使⽤⽽不是去创建注解。

例如，在Java源代码⾥不难找到Java编译器处理的@Override注解，Spring框架的@Autowired注解，或Hibernate框架使⽤的@Entity 注解，但我们很少看到⾃定义注解。

虽然⾃定义注解是Java语⾔中经常被忽视的⼀个⽅⾯，但在开发可读性代码时它可能是⾮常有⽤的资产，同样有助于理解常见框架（如Spring或Hibernate）如何简洁地实现其⽬标。

在本⽂中，我们将介绍注解的基础知识，包括注解是什么，它们如何在⽰例中使⽤，以及如何处理它们。

为了演⽰注解在实践中的⼯作原理，我们将创建⼀个Javascript Object Notation（JSON）序列化程序，⽤于处理带注解的对象并⽣成表⽰每个对象的JSON字符串。

在此过程中，我们将介绍许多常见的注解块，包括Java反射框架和注解可见性问题。

感兴趣的读者可以在GitHub上找到已完成的JSON序列化程序的源代码。

什么是注解？注解是应⽤于Java结构的装饰器，例如将元数据与类，⽅法或字段相关联。

这些装饰器是良性的，不会⾃⾏执⾏任何代码，但运⾏时，框架或编译器可以使⽤它们来执⾏某些操作。

更正式地说，Java语⾔规范（JLS）第9.7节提供了以下定义：注解是信息与程序结构相关联的标记，但在运⾏时没有任何影响。

请务必注意此定义中的最后⼀句：注解在运⾏时对程序没有影响。

这并不是说框架不会基于注解的存在⽽改变其运⾏时⾏为，⽽是包含注解本⾝的程序不会改变其运⾏时⾏为。

虽然这可能看起来是细微差别，但为了掌握注解的实⽤性，理解这⼀点⾮常重要。

例如，某个实例的字段添加了@Autowired注解，其本⾝不会改变程序的运⾏时⾏为：编译器只是在运⾏时包含注解，但注解不执⾏任何代码或注⼊任何逻辑来改变程序的正常⾏为（忽略注解时的预期⾏为）。

Java基础加强总结（一）——注解（Annotation）

Java基础加强总结（一）——注解（Annotation）

Java基础加强总结（⼀）——注解（Annotation）⼀、认识注解 注解(Annotation)很重要，未来的开发模式都是基于注解的，JPA是基于注解的，Spring2.5以上都是基于注解的，Hibernate3.x以后也是基于注解的，现在的Struts2有⼀部分也是基于注解的了，注解是⼀种趋势，现在已经有不少的⼈开始⽤注解了，注解是JDK1.5之后才有的新特性JDK1.5之后内部提供的三个注解@Deprecated 意思是“废弃的，过时的”@Override 意思是“重写、覆盖”@SuppressWarnings 意思是“压缩警告”范例：注解的应⽤：1package cn.gacl.annotation;2/**3 * 此类是⽤来演⽰注解(Annotation)的应⽤的，注解也是JDK1.5新增加的特性之⼀4 * JDK1.5内部提供的三种注解是：@SuppressWarnings(":deprecation")、@Deprecated、@Override5 * @author孤傲苍狼6 *7*/8/**9 * 类名的命名是有讲究的，类名、属性名、变量名⼀般是名词，或者是形容词+名词，⽅法⼀般是动词，或者是动词+名词，10 * 以AnnotationTest作为类名和以TestAnnotation作为类名是有区别的，11 * 前者是注解的测试，符合名词的特征，后者是测试注解，听起来就是⼀个动作名称，是⽅法的命名特征12*/13public class AnnotationTest {14/**15 * @param args16*/17 @SuppressWarnings(":deprecation")18//这⾥就是注解，称为压缩警告，这是JDK内部⾃带的⼀个注解，⼀个注解就是⼀个类，在这⾥使⽤了这个注解就是创建了SuppressWarnings类的⼀个实例对象19public static void main(String[] args) {20 System.runFinalizersOnExit(true);21//The method runFinalizersOnExit(boolean) from the type System is deprecated(过时的，废弃的)22//这⾥的runFinalizersOnExit()⽅法画了⼀条横线表⽰此⽅法已经过时了，不建议使⽤了23 }24 @Deprecated //这也是JDK内部⾃带的⼀个注解，意思就是说这个⽅法已经废弃了，不建议使⽤了25public static void sayHello(){26 System.out.println("hi,孤傲苍狼");27 }28 @Override //这也是JDK1.5之后内部提供的⼀个注解，意思就是要重写(覆盖)JDK内部的toString()⽅法29public String toString(){30return "孤傲苍狼";31 }32 } 总结：注解(Annotation)相当于⼀种标记，在程序中加⼊注解就等于为程序打上某种标记，没有加，则等于没有任何标记，以后，javac 编译器、开发⼯具和其他程序可以通过反射来了解你的类及各种元素上有⽆何种标记，看你的程序有什么标记，就去⼲相应的事，标记可以加在包、类，属性、⽅法，⽅法的参数以及局部变量上。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Java实战篇：设计自己的Annotation【达内科技java培训】
Annotation在java的世界正铺天盖地展开,有空写这一篇简单的annotations的文章,算是关于Annotation入门的文章吧,希望能各位们能抛砖,共同学习......
不讲废话了,实践才是硬道理.
第一部分:了解一下java1.5起默认的三个annotation类型:
一个是@Override:只能用在方法之上的，用来告诉别人这一个方法是改写父类的。

一个是@Deprecated:建议别人不要使用旧的API的时候用的,编译的时候会用产生警告信息,可以设定在程序里的所有的元素上.
一个是@SuppressWarnings:这一个类型可以来暂时把一些警告信息消息关闭.
如果不清楚上面三个类型的具体用法，各位可以baidu或google一下的,很简单的。

第二部分:讲一下annotation的概念，再来讲一下怎样设计自己的annotation.
首先在jdk自带的ng.annotation包里,打开如下几个源文件:
1、源文件Target.java
代码
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTA TION_TYPE)
public @interface Target {
ElementType[] value();
}
其中的@interface是一个关键字，在设计annotations的时候必须把一个类型定义为@interface，而不能用class或interface关键字(会不会觉得sun有点吝啬,偏偏搞得与interface这么像).
2、源文件Retention.java
代码
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTA TION_TYPE)
public @interface Retention {
RetentionPolicy value();
}
看到这里，大家可能都模糊了,都不知道在说什么，别急，往下看一下.
在上面的文件都用到了RetentionPolicy，ElementType这两个字段,你可能就会猜到这是两个java文件.的确，这两个文件的源代码如下：
3、源文件RetentionPolicy.java
代码
public enum RetentionPolicy {
SOURCE,
CLASS,
RUNTIME
}
这是一个enum类型,共有三个值，分别是SOURCE,CLASS 和RUNTIME.
SOURCE代表的是这个Annotation类型的信息只会保留在程序源码里，源码如果经过了编译之后，Annotation的数据就会消失,并不会保留在编译好的.class文件里面。

ClASS的意思是这个Annotation类型的信息保留在程序源码里,同时也会保留在编译好的.class文件里
面,在执行的时候，并不会把这一些信息加载到虚拟机(JVM)中去.注意一下，当你没有设定一个Annotation 类型的Retention值时，系统默认值是CLASS.
第三个,是RUNTIME,表示在源码、编译好的.class文件中保留信息，在执行的时候会把这一些信息加载到JVM中去的．
举一个例子，如@Override里面的Retention设为SOURCE,编译成功了就不要这一些检查的信息;相反,@Deprecated里面的Retention设为RUNTIME,表示除了在编译时会警告我们使用了哪个被Deprecated的方法,在执行的时候也可以查出该方法是否被Deprecated.
4、源文件ElementType.java
代码
public enum ElementType {
TYPE, FIELD, METHOD, PARAM ETER, CONSTRUCTOR,
LOCAL_V ARIABLE, ANNOTA TION_TYPE,PACKAGE
}
＠Target里面的ElementType是用来指定Annotation类型可以用在哪一些元素上的.说明一下：TYPE(类型), FIELD(属性), METHOD(方法), PARAMETER(参数), CONSTRUCTOR(构造函数),LOCAL_V ARIABLE(局部变量), ANNOTA TION_TYPE,PACKAGE(包),其中的TYPE(类型)是指可以用在Class,Interface,Enum和Annotation类型上.
另外,从1的源代码可以看出,@Target自己也用了自己来声明自己,只能用在ANNOTA TION_TYPE之上. 如果一个Annotation类型没有指明@Target使用在哪些元素上,那么它可以使用在任何元素之上,这里的元素指的是上面的八种类型.
举几个正确的例子:
@Target(ElementType.METHOD)
@Target(value=ElementType.METHOD)
@Target(ElementType.METHOD,ElementType.CONSTRUCTOR)
具体参考一下javadoc文档
上面一下1和2的源文件，它们都使用了@Documented,@Documented的目的就是让这一个Annotation 类型的信息能够显示在javaAPI说明文档上;没有添加的话，使用javadoc生成API文档的时候就会找不到这一个类型生成的信息.
另外一点，如果需要把Annotation的数据继承给子类，那么就会用到@Inherited这一个Annotation类型.
本文由达内科技培训机构整理，转载请注明出处！达内科技培训：java培训,java培训机构,java培训课程,java 培训班,java培训实战。

相关文档
最新文档