精华内容
参与话题
问答
  • Annotation注解

    2019-01-08 16:08:37
    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...


    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.

    注解是一种可以添加到Java源代码中元数据形式, 可以注解类、方法、变量、参数、包。
    注解对其注释的代码的运行没有直接影响。(不直接影响代码执行,只是一种标记)
    

    注解属于 Java中的一种类型,通过@interface标记, Java SE 5.0开始引入,

    使用场景:

    • 测试框架JUnit = 采用注解进行代码测试 (测试代码)
    • 网络请求库 Retrofit & IOC 框架ButterKnife (简化使用 & 降低代码量)

    Annotation的作用:

    • 标记,用于告诉编译器一些信息
    • 编译时动态处理,如动态生成代码
    • 运行时动态处理,如得到注解信息,反射

    一、Annotation的分类:

    标准 Annotation、元 Annotation、自定义 Annotation

    1、标准 Annotation

    Java 自带的几个 Annotation

    	@Override 标记该方法被子类复写
        @Deprecated 标记已过时 & 被抛弃的元素(类、方法等)
        @SuppressWarnings 标记的元素会阻止编译器发出警告提醒,忽略某项 Warning
        @SafeVarargs 参数安全类型注解,java1.7引入(需要自行解决问题)
        @FunctionalInterface 函数式接口注解,java1.8引入
    

    2、元 Annotation

    @Documented、@Retention、@Target、@Inherited,元Annotation是作为自定义 Annotation 的修饰符  
    

    @Documented
    带有这个注解,意味着被这个注解标志的注解会保存到 Javadoc 文档中
    @Retention
    保留时间可选值 SOURCE,CLASS,RUNTIME,默认为 CLASS。

      	@Retention(RetentionPolicy.SOURCE)
        注解只在源码阶段保留 & 在编译器进行编译时将被丢弃忽视。
        @Retention(RetentionPolicy.CLASS)
        注解只被保留到编译进行时(.java/.class& 不会被加载到 JVM 
        @Retention(RetentionPolicy.RUNTIME)
        注解保留到程序运行时 & 会被加载进入到 JVM 中,所以在程序运行时可以获取到它们
    

    @Target
    可以用来修饰哪些程序元素,如 TYPE、 METHOD、CONSTRUCTOR、 FIELD、PARAMETER 等,未标注则表示可修饰所有

     	@Target(ElementType.TYPE)   
        可以给一个类型进行注解,如接口、类、枚举、注解
        @Target(ElementType.FIELD)
    	属性
        @Target(ElementType.METHOD)
        方法
        @Target(ElementType.PARAMETER)
        方法参数
        @Target(ElementType.CONSTRUCTOR)  
        构造函数
        @Target(ElementType.LOCAL_VARIABLE)
        局部变量
        @Target(ElementType.ANNOTATION_TYPE)
        注解
    	@Target(ElementType.PACKAGE)

    @Inherited
    带有这个注解,意味着一个 被@Inherited标记的注解 作用的类的子类可以继承该类的注解
    @Repeatable
    可重复注解,Java1.8后引入

    3、自定义 Annotation

    自定义 Annotation 表示自己根据需要定义的 Annotation,定义时需要用到上面的元 Annotation

    3.1、 编译时动态处理
    • android studio:file - new module - javaLib 定义个javaLib 的module(命名为processor)
    • 在此module下定义编译时注解,定义一个注解处理类(javapoet相关工具生成java文件)
    • 注解处理类的全类名需要配置在src\main\resources\META-INF\services\javax.annotation.processing.Processor下
    • app module的dependencies,依赖引用这个module,implementation project(’:processor’)
    • app module的 android{ defaultConfig { }}配置如下,apt工具处理

    3.1.1、定义一个编译时注解

    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.CLASS)
    public @interface ZhenAnnotation {
        String name() default "undefined";
    
        String text() default "";
    }
    

    3.1.2、自定义一个ZhenProcessor ,继承自AbstractProcessor

    @SupportedAnnotationTypes("com.example.processor.ZhenAnnotation")
    @SupportedSourceVersion(SourceVersion.RELEASE_7)
    public class ZhenProcessor extends AbstractProcessor {
    
        private Types mTypeUtils;
        private Elements mElementUtils;
        private Filer mFiler;
        private Messager mMessager;
    
        @Override
        public synchronized void init(ProcessingEnvironment processingEnv) {
            super.init(processingEnv);
            //初始化我们需要的基础工具
            mTypeUtils = processingEnv.getTypeUtils();
            mElementUtils = processingEnv.getElementUtils();
            mFiler = processingEnv.getFiler();
            mMessager = processingEnv.getMessager();
        }
    
        @Override
        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
            // 遍历所有被注解了@ZhenAnnotation的元素
            for (Element annotatedElement : roundEnv.getElementsAnnotatedWith(ZhenAnnotation.class)) {
                // 检查被注解为@Factory的元素是否是一个类
                if (annotatedElement.getKind() != ElementKind.CLASS) {
                    error(annotatedElement, "Only classes can be annotated with @%s",
                            ZhenAnnotation.class.getSimpleName());
                    return true; // 退出处理
                }
                //解析,并生成代码
                analysisAnnotated(annotatedElement);
            }
            return false;
        }
        
        private void error(Element e, String msg, Object... args) {
            mMessager.printMessage(Diagnostic.Kind.ERROR, String.format(msg, args), e);
        }
    
        private static final String SUFFIX = "$$ZHEN";
    
        private void analysisAnnotated(Element classElement)
        {
            ZhenAnnotation annotation = classElement.getAnnotation(ZhenAnnotation.class);
            String name = annotation.name();
            String text = annotation.text();
    //        TypeElement superClassName = mElementUtils.getTypeElement(name);
            String newClassName = name + SUFFIX;
            StringBuilder builder = new StringBuilder()
                    .append("package com.example.processor.auto;\n\n")
                    .append("public class ")
                    .append(newClassName)
                    .append(" {\n\n") // open class
                    .append("\tpublic String getMessage() {\n") // open method
                    .append("\t\treturn \"");
            // this is appending to the return statement
            builder.append(text).append(name).append(" !\\n");
            builder.append("\";\n") // end return
                    .append("\t}\n") // close method
                    .append("}\n"); // close class
            try { // write the file
                JavaFileObject source = mFiler.createSourceFile("com.example.processor.auto."+newClassName);
                Writer writer = source.openWriter();
                writer.write(builder.toString());
                writer.flush();
                writer.close();
            } catch (IOException e) {
                // Note: calling e.printStackTrace() will print IO errors
                // that occur from the file already existing after its first run, this is normal
            }
        }
    }
    
    

    3.1.3、配置processor
    需要配置这个东西,将自定义Annotation的路径,写在这个javax.annotation.processing.Processor中
    在这里插入图片描述
    3.1.4、依赖引用processor

    android {
        defaultConfig {
            javaCompileOptions { annotationProcessorOptions { includeCompileClasspath = true } }
        }
    }
    
    dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        implementation project(':processor') //依赖引用
    }
    

    3.1.5、动态生成java文件

    • 使用编译时注解ZhenAnnotation
    • rebuild Project
    @ZhenAnnotation(name = "zhenzhen", text = "哈哈哈哈嘿! ")
    public class CompileAnnoActivity extends AppCompatActivity {
    }
    

    动态生成的java文件
    在这里插入图片描述
    rebuild project,

    3.2、 运行时动态处理

    运行时 Annotation 指 @Retention 为 RUNTIME 的 Annotation,可手动调用下面常用 API 解析

    判断该类是否应用了某个注解
    clazz.getAnnotation(AnnotationName.class); //返回指定类型的注解,可被多个 Annotation 修饰
    clazz.getAnnotations(); //返回该元素上的所有注解
    clazz.isAnnotationPresent(AnnotationName.class); //是否存在某注解标记
    

    定义一个运行时注解

    @Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @Inherited
    public @interface MethodInfo {
    
        String author() default "zhen";
    
        String date();
    
        int version() default 1;
    }
    

    (1). 通过 @interface 定义,注解名即为自定义注解名

    (2). 注解配置参数名为注解类的方法名,且:
    a. 所有方法没有方法体,没有参数没有修饰符,实际只允许 public & abstract 修饰符,默认为 public,不允许抛异常
    b. 方法返回值只能是基本类型,String, Class, annotation, enumeration 或者是他们的一维数组
    c. 若只有一个默认属性,可直接用 value() 函数。一个属性都没有表示该 Annotation 为 Mark Annotation

    (3). 可以加 default 表示默认值

    通过注解拿到方法相关信息

    public class AnnotationTest {
        
        @MethodInfo(author = "zhenzhen", date = "2019/1/7", version = 2)
        public static void getUserName() {
        }
        
        public static void main(String[] args) {
            Class clazz = AnnotationTest.class;
            Method[] methods = clazz.getDeclaredMethods();
            for (Method method : methods) {
                MethodInfo methodInfo = method.getAnnotation(MethodInfo.class);
                if (methodInfo != null) {
                    System.out.println("methodInfo.author(): " + methodInfo.author());
                    System.out.println("methodInfo.date(): " + methodInfo.date());
                    System.out.println("methodInfo.version(): " + methodInfo.version());
                }
            }
        }
    }
    

    举例:

    1、Butterknife原理解析

    1. @BindView、@OnClick编译时注解,在编译时生成xxx_ViewBinding的java文件

    2. 通过Butterknife.bind(this)进行绑定,通过类加载反射得到xxx_ViewBinding实例,并缓存

    3. 通过xxx_ViewBinding实例调用方法,进行resId和view绑定,如果是OnClick,还需要回调xxx中定义的点击方法

    4. xxx_ViewBinding中还有一个unbind(),用于解绑释放资源
      在这里插入图片描述
      1、EventBus原理解析

    5. @Subscribe运行时注解,通过反射拿到被注解方法的相关信息,保存event、subscribeMethod的键值对

    6. 在接收到指定Event时,取出相应的subscribeMethod,回调执行注解方法

    二、APT

    APT(Annotation Processing Tool)是一种处理注释的工具,它对源代码文件进行检测找出其中的Annotation,根据注解自动生成代码。

    Annotation处理器在处理Annotation时,可以根据源文件中的Annotation生成额外的源文件和其它的文件(文件具体内容由Annotation处理器的编写者决定),APT还会编译生成的源文件和原来的源文件,将它们一起生成class文件。
    APT的处理要素
    注解处理器(AbstractProcess)+代码处理(javaPoet)+处理器注册(AutoService)+apt

    使用APT来处理annotation的流程
      1. 定义注解(如@BindView),扫描代码中的注解
      2. 定义注解处理器(自定义注解处理器继承自AbstractProcessor),一般会生成.java文件
      3.使用处理器,编译处理生成的.java文件。
      4.APT自动完成如下工作。
    

    annotationProcessor是APT工具中的一种,他是google开发的内置框架,不需要引入,可以直接在build.gradle文件中使用,如下

    dependencies {
        annotationProcessor "com.jakewharton:butterknife-compiler:8.8.1"
    }
    

    为了让java编译器识别出这个自定义的Processor,需要配置META-INF中的文件,将这个自定义的类名注册进去。

    参考:
    公共技术点之 Java 注解 Annotation
    聊聊编译时注解(一)
    annotationprocessing101

    展开全文
  • 一直在使用,也知道@Override的意义,但是并没有深究下去,如果我们进入@Override的类Override.java可以看到:import java.lang.annotation.*; @Target(ElementType.METHOD) @Retention(RetentionPolicy.SOURCE) ...

    从@Override说起
    一直在使用,也知道@Override的意义,但是并没有深究下去,如果我们进入@Override的类Override.java可以看到:

    import java.lang.annotation.*;
    
    
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.SOURCE)
    public @interface Override {
    }

    如果继续点击@Target进入Target.java

    package java.lang.annotation;
    
    
    @Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.ANNOTATION_TYPE)
    public @interface Target {
        ElementType[] value();
    }

    然后在Target.java所在的包中还可以看到其它的注解类
    这里写图片描述

    上图红框中的5个类(不同的版本个数不同)都是注解类,而且是元注解.

    那什么是注解?
    Annotation(注解)就是Java提供了一种元程序中的元素关联任何信息和着任何元数据(metadata)的途径和方法.
    关于注解的定义,这篇文章比较正式:http://www.cnblogs.com/peida/archive/2013/04/23/3036035.html

    什么是元注解
    元注解的作用就是负责注解其他注解,比如:

    1.@Target,    //说明了Annotation所修饰的对象范围

    2.@Retention,    //定义了该Annotation被保留的时间长短

    3.@Documented, //用于描述其它类型的annotation应该被作为被标注的程序成员的公共API,因此可以被例如javadoc此类的工具文档化

    4.@Inherited //是一个标记注解,@Inherited阐述了某个被标注的类型是被继承的

    4.@Repeatable //java8 新增的@Repeatable注解

    通过这些元注解,我们可以自定义自己的注解类,下次我们将看看如何自定义注解和使用注解.
    关于元注解:http://www.cnblogs.com/peida/archive/2013/04/23/3036035.html

    展开全文
  • Hibernate的Annotation注解

    千次阅读 2013-05-18 22:26:48
    当项目变得比较大的时候,如何...这里Hibernate提供了Annotation注解方式,使得Hibernate的映射文件变得很方便管理了。  这里简单介绍Hibernate的Annotation注解  一、声明实体  @Entity  对实体注释。任何Hibe

            当项目变得比较大的时候,如何还使用hbm.xml文件来配置Hibernate实体就会变得比较复杂。这里Hibernate提供了Annotation注解方式,使得Hibernate的映射文件变得很方便管理了。

            这里简单介绍Hibernate的Annotation注解

            一、声明实体

            @Entity

                对实体注释。任何Hibernate映射对象都要有这个注释

            @Table

               声明此对象映射到数据库的数据表,通过它可以为实体指定表(talbe),目录(Catalog)和schema的名字。该注释不是必须的,如果没有则系统使用默认值(实体的短类名)。

             @Version

                 该注释可用于在实体Bean中添加乐观锁支持。

     

            二、声明主键

            @Id

               声明此属性为主键。该属性值可以通过应该自身创建,但是Hibernate推荐通过Hibernate生成

            @GeneratedValue

               指定主键的生成策略。有如下四个值

                   TABLE:使用表保存id值

                   IDENTITY:identitycolumn

                   SEQUENCR :sequence

                   AUTO:根据数据库的不同使用上面三个

            

            三、声明普通属性

            @Column

               声明该属性与数据库字段的映射关系。

    @Column(nam=”category_name” length=20)
    Public void getCategoryName(){
    	Return this.categoryName;
    }

            注意:

              1、  当POJO有属性不需要映射的时候一定要用@Transitent修饰,该注释表示此属性与表没有映射关系,只是一个暂时的属性。

              2、  @Lob注释表示该属性持久化为Blob或者Clob类型,具体取决于属性的类型。

     

            四、声明关联关系

            一对多关联关系

            @OneToMany(mappedBy=” person”,cascade=CascadeType.ALL,fetch=FetchType.LAZY)

             一对多声明

            @ManyToOne(cascade=CascadeType.REFRESH,)

            @JoinColumn

             多对一声明 ,声明为双向关联


    一对一关联关系

            @OneToOne(optional= true,cascade =CascadeType.ALL, mappedBy = “person”)
             一对一关联声明
            @OneToOne(optional = false, cascade = CascadeType.REFRESH)
            @JoinColumn(name = “Person_ID”, referencedColumnName = “personid”,unique = true)
             声明为双向关联


    多对多关联关系

            @ManyToMany(mappedBy= “students”)
             多对多关联声明。
            @ManyToMany(cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
            @JoinTable(name = “Teacher_Student”,
            joinColumns = {@JoinColumn(name = “Teacher_ID”, referencedColumnName =“teacherid”)},
            inverseJoinColumns = {@JoinColumn(name = “Student_ID”, referencedColumnName =“studentid”)})


            实例:

            有如下两个实体,商品:Goods,分类Category。两者是多对一的关联关系。

            使用Hibernate Annotation注解如下

    Goods.java

    @Entity
    @Table(name = "goods", catalog = "test")
    public class Goods implements java.io.Serializable {
    
    	private static final long serialVersionUID = 1L;
    	private String goodsId;
    	private Category category;
    	private String goodsName;
    
    	public Goods() {
    	}
    
    	/*
    	 * 主键
    	 * 生成策略为自动增长
    	 * 唯一、长度为20
    	 */
    	@Id
    	@GeneratedValue
    	@Column(name = "goods_id", unique = true, nullable = false, length = 20)
    	public String getGoodsId() {
    		return this.goodsId;
    	}
    
    	public void setGoodsId(String goodsId) {
    		this.goodsId = goodsId;
    	}
    
    	/*
    	 * 多对一关联关系
    	 * 延迟加载:fetch = FetchType.LAZY
    	 * 引用外键:category_id
    	 * 
    	 */
    	@ManyToOne(fetch = FetchType.LAZY,cascade=CascadeType.ALL)
    	@JoinColumn(name = "category_id")
    	public Category getCategory() {
    		return this.category;
    	}
    
    	public void setCategory(Category category) {
    		this.category = category;
    	}
    
    	@Column(name = "goods_name", nullable = false, length = 50)
    	public String getGoodsName() {
    		return this.goodsName;
    	}
    
    	public void setGoodsName(String goodsName) {
    		this.goodsName = goodsName;
    	}
    
    }


    Category.java
    
    


    @Entity
    @Table(name = "category", catalog = "test")
    public class Category implements java.io.Serializable {
    
    	private static final long serialVersionUID = -1877960009126534682L;
    
    	private String categoryId;
    	private String categoryName;
    	private Set<Goods> goodses = new HashSet<Goods>(0);
    
    	public Category() {
    	}
    
    	/*
    	 * 主键
    	 * 生成策略为自动增长
    	 * 唯一、长度为20
    	 */
    	@Id
    	@GeneratedValue
    	@Column(name = "category_id", unique = true, length = 10)
    	public String getCategoryId() {
    		return this.categoryId;
    	}
    
    	public void setCategoryId(String categoryId) {
    		this.categoryId = categoryId;
    	}
    
    	@Column(name = "category_name", length = 20)
    	public String getCategoryName() {
    		return this.categoryName;
    	}
    
    	public void setCategoryName(String categoryName) {
    		this.categoryName = categoryName;
    	}
    
    	/*
    	 * 一对多关联关系
    	 * 级联关系:cascade=CascadeType.ALL
    	 * 延迟加载:fetch = FetchType.LAZY
    	 * 映射:mappedBy = "category"
    	 */
    	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "category")
    	public Set<Goods> getGoodses() {
    		return this.goodses;
    	}
    
    	public void setGoodses(Set<Goods> goodses) {
    		this.goodses = goodses;
    	}
    
    }

    
    
    展开全文
  • Java 核心基础(一)Annotation 注解

    万次阅读 2012-05-05 09:32:10
    Annotation 是 Java1.5 推出的新特性。它用来描述 Java 中的代码,如类、方法、字段等等。所以也把注解称之为元数据。 Java1.5 内置的常见的注解: @Deprecated @Override @Deprecated 使用 Java 内置的 @...

    Annotation 是 Java1.5 推出的新特性。它用来描述 Java 中的代码,如类、方法、字段等等。所以也把注解称之为元数据。

    Java1.5 内置的常见的注解:

    • @Deprecated
    • @Override
    • @Deprecated

    使用 Java 内置的 @Deprecated 注解,举个例子:

    @Deprecated
    public void test(){
        // do something
    }

    上面的 @Deprecated 注解使用在 Java 的方法上,表示说该方法已经废弃了,不建议使用者调用


    除了 @Deprecated 注解还有 @Override,表示该方法是重写父类的方法:

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

    在 JDK1.5 中除了内置上面两个注解外,还有 @SuppressWarnings该注解主要用于抑制编译器警告,例如:

    
    @SuppressWarnings("unchecked")
    public void testWarning() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
    }

    自定义注解

    在自定义注解之前,我们可以看下 JDK 内置的注解的源码,看看系统是怎么定义注解的,以 @Deprecated 为例:

    
    @Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
    public @interface Deprecated {
    
    }
    

    我们发现,Java 是通过 @interface 关键字来定义注解的。

    除此以外,我们还发现,在 @Deprecated 注解上还有 @Documented、@Target、@Retention 注解,这些注解用来描述 @Deprecated 注解的,我们把它称之为元注解。

    什么是元注解呢?就是描述注解的注解。什么是元数据呢?就是描述数据的数据。

    @Documented 元注解

    用来描述目标注解将被 javadoc 工具提取成文档。

    例如在 AnnotationTest 类上使用 @Deprecated 注解:

    @Deprecated
    public class AnnotationTest {
    
    }

    然后使用 javadoc 命令来生成文档,然后查看生成的文档 html :

    我们发现 @Deprecated 被提取到 API 文档上了。

    我们可以使用 @SuppressWarnings 注解来描述 AnnotationTest:

    @SuppressWarnings("unchecked")
    public class AnnotationTest {
    
    }

    @SuppressWarnings 注解没有被 @Documented 元注解修饰,所以 API 文档上不会有该注解。

    通过 javadoc 命令重新生成 API 文档:

    @Target 元注解

    描述目标注解用在哪个地方,比如:是用在方法上,还是用在类上。具体有哪些地方呢? Java 通过枚举列举出来了:

    public enum ElementType {
        // 类、接口、枚举
        TYPE,
    
        // 字段
        FIELD,
    
        // 方法
        METHOD,
    
        // 参数
        PARAMETER,
    
        // 构造函数
        CONSTRUCTOR,
    
        // 局部变量
        LOCAL_VARIABLE,
    
        // 注解
        ANNOTATION_TYPE,
    
        // 包
        PACKAGE,
    }

    @Retention 元注解

    用于描述目标注解保留在什么阶段。主要有三个阶段,定义在 RetentionPolicy 枚举类中:

    public enum RetentionPolicy {
    
        // 注解只保留在源码中,编译成 class 后就不存在了
        SOURCE,
    
        // 注解保留在 class 字节码中,这是默认值
        CLASS,
    
        // 注解保留到运行时,程序运行的时候也可以获取到该注解
        RUNTIME
    }

    @Inherited 元注解

    除了上面几个元注解,还有 @Inherited 元注解,该元注解表示目标注解具有继承性,听起来还是不好理解,下面通过例子来说明下:

    首先我们自定义一个注解(该注解被 @Inherited 元注解修饰):

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    public @interface BaseAnnotation {
    }

    然后新建一个类 BaseClass :

    @BaseAnnotation
    class BaseClass {
    
    }
    

    然后再新建一个类,然后继承上面的 BaseClass :

    public class InheritedTest extends BaseClass {
        public static void main(String[] args) {
            // InheritedTest 有没有被 BaseAnnotation 注解修饰?
            System.out.println(InheritedTest.class.isAnnotationPresent(BaseAnnotation.class));
        }
    }

    上面的程序输出 true。

    虽然我们的 InheritedTest 类并没有显式的被 BaseAnnotation 修饰,但是它的父类 BaseClass 被 BaseAnnotation 注解修饰了,又因为 BaseAnnotation 注解被元注解 @Inherited 修饰,所以具备继承性。InheritedTest 继承了 BaseClass,也把 BaseAnnotation 注解继承过来了。我们可以把 @Inherited 注解去掉,在运行程序,会输出 false,因为这个时候 BaseAnnotation 没有继承性了。

     

    注解与反射

    关于注解与反射相关的内容可以查看我的博客:《Java 核心基础(二)反射技术详解》

     


     

    展开全文
  • Java Annotation注解

    2018-12-05 09:03:04
    注解(Annotation)很重要,未来的开发模式都是基于注解的,JPA是基于注解的,Spring2.5以上都是基于注解的,Hibernate3.x以后也是基于注解的,现在的Struts2有一部分也是基于注解的了,注解是一种趋势,现在已经有...
  • annotation注解大全

    2017-12-09 22:34:06
    Java5.0定义了4个标准的meta-annotation类型,它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解:  1.@Target,  2.@Retention,  3.@Documented,  4.@Inherited  这些类型和它们所支持的类...
  • java Annotation注解

    2016-03-16 20:52:14
    Annotation注解)就是Java提供了一种元程序中的元素关联任何信息和着任何元数据(metadata)的途径和方法。Annotion(注解)是一个接口,程序可以通过反射来获取指定程序元素的Annotion对象,然后通过Annotion对象来...
  • Annotation注解

    2014-02-24 23:11:43
    Annotation是修饰AnnotationAnnotation,JDK具体元Annotation有: 1. @Retention 只能修饰一个Annotation, 定义用来指定该Annotation可以保留的域。它包含一个RetentionPolicy类型成员变量,通过指定该变量的值...
  • Annotation注解处理器

    2014-01-11 23:18:36
    如果没有用来读取注解的方法和工作,那么注解也就不会比注释更有用处了。使用注解的过程中,很重要的一部分就是创建于使用注解处理器。... Java使用Annotation接口来代表程序元素前面的注解,该接口是所有Anno
  • Java annotation 注解

    2014-05-15 01:09:14
    Java中的注解 注解在进货
  • Java Annotation 注解

    2012-03-23 15:06:23
    Annotation注解)是什么? 附加在代码中的一些元信息,用于一些工具在编译、运行时进行解析和使用,起到说明、配置的功能。 注解不会也不能影响代码的实际逻辑,仅仅起到辅助性的作用。包含在 java.lang....
  • Annotation注解添加各种属性

    千次阅读 2012-02-05 17:22:45
    但是从 Java语音规范中得知,对于注解的属性类型 有限制 只能是 八个原始类型 String类型 Enum类型 Annotation注解类型 以及 Class类型 ,出了以上几个类型之外 为注解添加属性都会报错 public @interface ...
  • Android APT开发教程 一 Annotation注解

    千次阅读 2018-01-19 19:36:09
    首先说一下Annotation注解这方面的基础知识,贴出官方说明文字,大家看完再说如何去用 1.@Target:  规定Annotation所修饰的对象范围。  ElementType.CONSTRUCTOR:构造器声明  Elem
  • Annotation注解详细介绍

    千次阅读 2018-09-23 12:01:59
    目录介绍 1.Annotation库的简单介绍 2.@Nullable和@NonNull 3.资源类型注释 ...12.@SuppressWarnings注解 13.其他 1.Annotation库的简单介绍 包含一系列有用元注释,帮助开发者在编译期间发现可...
  • annotation注解详解java

    2017-03-16 16:01:44
     注解(Annotation)很重要,未来的开发模式都是基于注解的,JPA是基于注解的,Spring2.5以上都是基于注解的,Hibernate3.x以后也是基于注解的,现在的Struts2有一部分也是基于注解的了,注解是一种趋势,现在已经有...
  • annotation注解的使用

    2010-12-18 17:18:00
    import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Retention...
  • annotation注解学习(by quqi99)

    千次阅读 2009-06-19 22:35:00
    annotation注解学习(by quqi99) 作者:张华 发表于:2009-06-19 ( http://blog.csdn.net/quqi99 )版权声明:可以任意转载,转载时请务必以超链接形式标明文章原始出处和作者信息及本版权声明。 1) 定义注解: ...
  • 这里碰到了一个问题 ,执行的方法有注解,但是通过Annotation an = method.getAnnotation(UserChangeLog.class); 取值为null.具体情况和此篇文章类似:示例其实问题很简单,是代理对象和目标对象的问题,通过代理...
  • 给编译器看的注释——Annotation java.lang.annotation,接口Annotation。 Annotations提供一些本来不属于程序的数据,比如:一段代码的作者或者告诉编译器禁止一些特殊的错误。An annotation 对代码的执行...
  • 该功能由一个定义注解类型的语法和描述一个注解声明的语法,读取注解的API,一个使用注解修饰的class文件和一个注解处理工具组成。 Annotation并不直接影响代码的语义,但是他可以被看做是程序的工具或者类库。它会...
  • import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(ElementType.CONSTRUCTOR) //...
  • Java/Android Annotation注解注入(二) import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target;...
  • Android Annotation注解学习笔记

    千次阅读 2016-09-07 17:35:25
    今天讲下注解吧,现在遇到的用注解的开源库越来越多,虽然知道怎么用,但是其原理,怎么写都还不清楚。学习了一些网站和资料,先...Java基础加强总结(一)——注解(Annotation)注解的分类方式有很多: 标准的Annotati
  • Struts2 annotation注解验证

    千次阅读 2012-05-25 19:51:46
    struts2的验证分为分编程式验证、声明式验证、注解式验证。这里采用的是注解式验证。 1、首先查看API文档,查看struts2注解验证的使用  Home > Guides > Core Developers Guide > Annotations /**  * ...
  • Spring下Hibernate Annotation注解

    千次阅读 2008-12-20 20:19:00
    在spring+hibernate环境下使用Hibernate Annotation,其实主要的就是对hibernate实体类的注解。这里要注意的一个问题是要使用包javax.persistence.Entity;下面的注解,而不是org.hibernate.annotation.Entity;接下来...
  • java annotation 注解 异常处理

    千次阅读 2014-06-13 14:49:02
    import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method;...import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.a

空空如也

1 2 3 4 5 ... 20
收藏数 297,194
精华内容 118,877
关键字:

annotation