精华内容
下载资源
问答
  • 主要介绍了Java 注解使用实例详解的相关资料,需要的朋友可以参考下
  • 主要介绍了Java注解简单使用实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了深入理解 Java注解实例的相关资料,希望通过本文大家能够掌握java注解的知识,需要的朋友可以参考下
  • Java注解使用案例总结一、java注解说明1.1官网解释1.2注解分类1.2.1内置普通注解1.2.2内置元注解1.2.3自定义注解1) 注解基本语法2) 注解范围和生命周期 一、java注解说明 1.1官网解释 Java 注解用于为 Java 代码提供...

    一、java注解说明和自定义

    1.1官网解释

    Java 注解用于为 Java 代码提供元数据。作为元数据,注解不直接影响你的代码执行,但也有一些类型的注解实际上可以用于这一目的。Java 注解是从 Java5 开始添加到 Java 的。

    通俗理解注解像是一个标记,可以标记在类、属性、方法等,通过反射机制动态获取标记的值,然后通过自定义注解处理器,实现自己的业务逻辑。

    1.2注解分类

    此处列举java7的常用注解,java8以后有新的内置注解。

    1.2.1内置普通注解

    作用于普通类和接口的注解

    注解 说明
    @Deprecated 主要标记过去的方法和类。如果使用标记的方法,会报编译警告
    @Override 检查该方法是否是重写方法
    @SuppressWarnings 忽视编译器的编译警告

    1.2.2内置元注解

    作用与自定义注解(Annotation)时使用,相当于自定注解时使用的注解。

    注解 说明
    @Documented 表示自定义注解是否通过javadoc生成到文档中
    @Inherited 它所标注的Annotation具有继承性,标记此注解类的子类也具有父类的注解。
    @Retention 用来说明该注解类的生命周期。结合枚举RetentionPolicy控制生命阶段。源码(java)、字节码(class)、运行(JVM)
    @Target 用来声明注解的使用范围。集合ElementType属性控制使用范围是方法、类、字段等

    1.2.3自定义注解

    a) 注解基本语法

    自定义注解语法和接口类似,通过@interface表示

    // 不添加@Target。默认全部
    @Target(ElementType.TYPE)
    // 不添加@Retention。默认为RetentionPolicy.CLASS
    @Retention(RetentionPolicy.RUNTIME)
    public @interface TestAnnotation{
        String value() default "";
    }
    
    b) 注解范围和生命周期

    @Target结合ElementType控制注解的使用范围,比如只能标记方法或者只能标记类。
    java8以后有新增,此处列举java7常用属性。

    package java.lang.annotation;
    
    public enum ElementType {
        
        TYPE, /**类、接口(包括批注类型)、枚举 */
    
        FIELD, /** 字段声明 */
    
        METHOD, /** 方法声明 */
    	
        PARAMETER,/** 形参数声明 */
    
        CONSTRUCTOR, /** 构造函数声明 */
    
        LOCAL_VARIABLE, /** 局部变量声明 */
    
        ANNOTATION_TYPE, /** 注释类型声明 */
    
        PACKAGE,/** 包声明 */
    }
    

    @Retention结合RetentionPolicy控制注解的生命阶段

    package java.lang.annotation;
    
    public enum RetentionPolicy {
        /**
         * 源码阶段。java源码存在,经过编译器处理,编译成class后丢弃
         */
        SOURCE,
        /**
         * 字节码阶段。java源码和编译成class时存在,JVM在运行时不保留注释。这是默认行为
         */
        CLASS,
        /**
         * 运行阶段。。java源码和编译成class时存在,并且在运行时由JVM保留,因此可以反射地读取它们
         */
        RUNTIME
    }
    

    二、自定义注解使用案例

    前面初步说明注解的定义,此处说明注解的使用,主要通过java反射操作。

    RetentionPolicy生命周期说明
    可以通过反编译工具查看注解源码编译后的对应的class文件

    级别 编译后 运行期 说明
    SOURCE 不存在 NULL 源码编译后,字节码文件中不存在注解代码
    CLASS 存在 NULL 字节码文件存在注解代码,运行期间无法通过反射无法获取对象
    RUNTIME 存在 注解对象 字节码文件存在注解代码,运行期间无法可以通过反射获取注解对象

    2.1注解在运行期调用的案例

    定义注解并标记生命周期和范围,通过自定义处理器解决业务问题。

    案例中注解生命周期使用RetentionPolicy.RUNTIME,所以可以通过反射动态获取注解的值。

    package com.cs.spring.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 模拟SpringMVC中的Controller注解
     */
    // 指定在类、接口头部标记,如果其他地方编译报错
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Controller {
        /**
         * 请求模块路径
         */
        String value() ;
    }
    
    package com.cs.spring.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 模拟SpringMVC中的RequestMapping注解
     */
    // 指定在方法头部标记,如果其他地方编译报错
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface RequestMapping {
        /**
         * 请求api路径
         */
        String value();
        /**
         * 请求方式
         */
        String[] method() default {};
    }
    
    package com.cs.spring;
    
    import com.cs.spring.annotation.Controller;
    import com.cs.spring.annotation.RequestMapping;
    
    /**
     * 模拟api接口
     */
    @Controller("/user")
    class UserRest {
    
        @RequestMapping(value = "/addUser", method = {"POST", "GET"})
        public void addUser() {
            System.out.println("addUser");
        }
    }
    
    
    public class Test {
        public static void main(String[] args) throws NoSuchMethodException {
            Controller controller = UserRest.class.getAnnotation(Controller.class);
            System.out.println("Controller注解    value=" + controller.value());
    
            RequestMapping requestMapping = UserRest.class.getMethod("addUser").getAnnotation(RequestMapping.class);
            System.out.println("RequestMapping注解  value=" + requestMapping.value() + "   method=" + requestMapping.method()[0]);
        }
    }
    

    运行结果
    在这里插入图片描述

    2.2注解在编译器调用的案例

    java6 以后提供了编译期处理注解的方式,通过继承AbstractProcessor(注解处理器)类实现。
    lombok采用的就是此方式

    TODO
    
    展开全文
  • 深入JAVA注解(Annotation):自定义注解

    万次阅读 多人点赞 2019-07-31 18:40:53
    要深入学习注解,我们就必须能定义自己的注解,并使用注解,在定义自己的注解之前,我们就必须要了解Java为我们提供的元注解和相关定义注解的语法。 元注解:  元注解的作用就是负责注解其他注解Java5.0定义了4...

    一、基础知识:元注解

     

    要深入学习注解,我们就必须能定义自己的注解,并使用注解,在定义自己的注解之前,我们就必须要了解Java为我们提供的元注解和相关定义注解的语法。

    元注解:

      元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型,它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解:
        1.@Target,
        2.@Retention,
        3.@Documented,
        4.@Inherited
      这些类型和它们所支持的类在java.lang.annotation包中可以找到。下面我们看一下每个元注解的作用和相应分参数的使用说明。

      @Target:

       @Target说明了Annotation所修饰的对象范围:Annotation可被用于 packages、types(类、接口、枚举、Annotation类型)、类型成员(方法、构造方法、成员变量、枚举值)、方法参数和本地变量(如循环变量、catch参数)。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。

      作用:用于描述注解的使用范围(即:被描述的注解可以用在什么地方)

      取值(ElementType)有:

        1.CONSTRUCTOR:用于描述构造器
        2.FIELD:用于描述域
        3.LOCAL_VARIABLE:用于描述局部变量
        4.METHOD:用于描述方法
        5.PACKAGE:用于描述包
        6.PARAMETER:用于描述参数
        7.TYPE:用于描述类、接口(包括注解类型) 或enum声明

      使用实例:  

    复制代码

    @Target(ElementType.TYPE)
    public @interface Table {
        /**
         * 数据表名称注解,默认值为类名称
         * @return
         */
        public String tableName() default "className";
    }
    
    @Target(ElementType.FIELD)
    public @interface NoDBColumn {
    
    }

    复制代码

      注解Table 可以用于注解类、接口(包括注解类型) 或enum声明,而注解NoDBColumn仅可用于注解类的成员变量。

      @Retention:

      @Retention定义了该Annotation被保留的时间长短:某些Annotation仅出现在源代码中,而被编译器丢弃;而另一些却被编译在class文件中;编译在class文件中的Annotation可能会被虚拟机忽略,而另一些在class被装载时将被读取(请注意并不影响class的执行,因为Annotation与class在使用上是被分离的)。使用这个meta-Annotation可以对 Annotation的“生命周期”限制。

      作用:表示需要在什么级别保存该注释信息,用于描述注解的生命周期(即:被描述的注解在什么范围内有效)

      取值(RetentionPoicy)有:

        1.SOURCE:在源文件中有效(即源文件保留)
        2.CLASS:在class文件中有效(即class保留)
        3.RUNTIME:在运行时有效(即运行时保留)

      Retention meta-annotation类型有唯一的value作为成员,它的取值来自java.lang.annotation.RetentionPolicy的枚举类型值。具体实例如下:

    复制代码

    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Column {
        public String name() default "fieldName";
        public String setFuncName() default "setField";
        public String getFuncName() default "getField"; 
        public boolean defaultDBValue() default false;
    }

    复制代码

       Column注解的的RetentionPolicy的属性值是RUTIME,这样注解处理器可以通过反射,获取到该注解的属性值,从而去做一些运行时的逻辑处理

      @Documented:

      @Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API,因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解,没有成员。

    复制代码

    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Column {
        public String name() default "fieldName";
        public String setFuncName() default "setField";
        public String getFuncName() default "getField"; 
        public boolean defaultDBValue() default false;
    }

    复制代码

      @Inherited:

      @Inherited 元注解是一个标记注解,@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class,则这个annotation将被用于该class的子类。

      注意:@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation,方法并不从它所重载的方法继承annotation。

      当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME,则反射API增强了这种继承性。如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时,反射代码检查将展开工作:检查class和其父类,直到发现指定的annotation类型被发现,或者到达类继承结构的顶层。

     

    实例代码:

    复制代码

    /**
     * 
     * @author peida
     *
     */
    @Inherited
    public @interface Greeting {
        public enum FontColor{ BULE,RED,GREEN};
        String name();
        FontColor fontColor() default FontColor.GREEN;
    }

    二、基础知识:自定义注解

     

    使用@interface自定义注解时,自动继承了java.lang.annotation.Annotation接口,由编译程序自动完成其他细节。在定义注解时,不能继承其他的注解或接口。@interface用来声明一个注解,其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称,返回值类型就是参数的类型(返回值类型只能是基本类型、Class、String、enum)。可以通过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 java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 水果名称注解
     * @author peida
     *
     */
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface FruitName {
        String value() default "";
    }

    复制代码

    复制代码

    package annotation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 水果颜色注解
     * @author peida
     *
     */
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @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。因此, 使用空字符串或0作为默认值是一种常用的做法。这个约束使得处理器很难表现一个元素的存在或缺失的状态,因为每个注解的声明中,所有元素都存在,并且都具有相应的值,为了绕开这个约束,我们只能定义一些特殊的值,例如空字符串或者负数,一次表示某个元素不存在,在定义注解时,这已经成为一个习惯用法。

    三、自定义注解实例

         以上都是一些注解的基础知识,这里讲一下自定义注解的使用。一般,注解都是搭配反射的解析器共同工作的,然后利用反射机制查看类的注解内容。如下:

     

    复制代码

     1 package testAnnotation;
     2 
     3 import java.lang.annotation.Documented;
     4 import java.lang.annotation.Retention;
     5 import java.lang.annotation.RetentionPolicy;
     6 
     7 @Documented
     8 @Retention(RetentionPolicy.RUNTIME)
     9 public @interface Person{
    10     String name();
    11     int age();
    12 }

    复制代码

     

     package testAnnotation;
     2 
     3 @Person(name="xingoo",age=25)
     4 public class test3 {
     5     public static void print(Class c){
     6         System.out.println(c.getName());
     7         
     8         //java.lang.Class的getAnnotation方法,如果有注解,则返回注解。否则返回null
     9         Person person = (Person)c.getAnnotation(Person.class);
    10         
    11         if(person != null){
    12             System.out.println("name:"+person.name()+" age:"+person.age());
    13         }else{
    14             System.out.println("person unknown!");
    15         }
    16     }
    17     public static void main(String[] args){
    18         test3.print(test3.class);
    19     }
    20 }

     

    运行结果:

    testAnnotation.test3
    name:xingoo age:25

    接下来再讲一个工作中的例子就可以收篇啦!

    LoginVerify注解是用于对标注的方法在进行请求访问时进行登录判断。

     

    package com.newsee.annotation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Inherited;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 是否已登录判断
     *
     */
    @Documented
    @Target(ElementType.METHOD)
    @Inherited
    @Retention(RetentionPolicy.RUNTIME)
    public @interface LoginVerify {
    
    }

     

    ScanningLoginVerifyAnnotation里的scanning()方法被@PostConstruct修饰,说明它在服务器加载Servlet的时候运行,并且只会被服务器执行一次。

     

    这里再科普一下:

     

    @PostConstruct和@PreDestroy。这两个注解被用来修饰一个非静态的void()方法 。写法有如下两种方式:

    @PostConstruct

    Public void someMethod() {}                                                                       
    或者

    public @PostConstruct void someMethod(){}

    被@PostConstruct修饰的方法会在服务器加载Servlet的时候运行,并且只会被服务器执行一次。PostConstruct会在构造函数之后,init()方法之前执行。PreDestroy()方法在destroy()方法执行之后执行

     

    scanning方法是在servlet加载完毕后获取所有被加载类,遍历其中的方法,如果有被LoginVerify注解修饰,则该方法名放到一个static的map中存储起来。

     

     

    package com.newsee.annotation;
    
    import java.io.IOException;
    import java.lang.reflect.Method;
    import javax.annotation.PostConstruct;
    import org.springframework.core.io.Resource;
    import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    import org.springframework.core.io.support.ResourcePatternResolver;
    import org.springframework.stereotype.Component;
    import org.springframework.util.ClassUtils;
    import com.newsee.constant.LoginVerifyMapping;
    
    @Component
    public class ScanningLoginVerifyAnnotation {
    	private static final String PACKAGE_NAME = "com.newsee.face";
    
    	private static final String RESOURCE_PATTERN = "/**/*.class";
    
    	@PostConstruct
    	public void scanning() throws IOException, SecurityException,
    			ClassNotFoundException {
    		String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
    				+ ClassUtils.convertClassNameToResourcePath(PACKAGE_NAME)
    				+ RESOURCE_PATTERN;
    		ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
    		Resource[] resources = resourcePatternResolver.getResources(pattern);
    		for (Resource resource : resources) {
    			if (resource.isReadable()) {
    				String className = getClassName(resource.getURL().toString());
    				Class cls = ScanningRequestCodeAnnotation.class.getClassLoader().loadClass((className));
    				for (Method method : cls.getMethods()) {
    					LoginVerify requestCode = method.getAnnotation(LoginVerify.class);
    					if (requestCode != null) {
    						</span>LoginVerifyMapping.add(className + "."+ method.getName());
    					}
    				}
    			}
    		}
    	}
    
    	private String getClassName(String resourceUrl) {
    		String url = resourceUrl.replace("/", ".");
    		url = url.replace("\\", ".");
    		url = url.split("com.newsee")[1];
    		url = url.replace(".class", "");
    		return "com.newsee" + url.trim();
    	}
    }
    

    LoginVerifyMapping就是存放被LoginVerify注解修饰的方法名的。

    public class LoginVerifyMapping {
    	private static Map<String, Boolean> faceFunctionIsNeedLoginVerify = new HashMap<String, Boolean>();
    
    	public static void add(String functionName) {
    		faceFunctionIsNeedLoginVerify.put(functionName, Boolean.TRUE);
    	}
    
    	public static Boolean getFaceFunctionIsNeedLoginVerify(String functionName) {
    		return faceFunctionIsNeedLoginVerify.get(functionName);
    	}
    }

    以下方法就是请求过来时判断请求的方法是不是在LoginVerifyMapping中,如果是,则需要进行登录校验。

    private ResponseContent handleRequests(RequestContent requestContent) throws ClassNotFoundException,
    			NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException,
    			InvocationTargetException {
    		String requestCode = requestContent.getRequest().getHead().getNWCode();
    		String className = RequestCodeMapping.getClassName(requestCode);
    		String beanName = RequestCodeMapping.getBeanName(requestCode);
    		String functionName = RequestCodeMapping.getFunctionName(requestCode);
    		Boolean loginVerify = LoginVerifyMapping.getFaceFunctionIsNeedLoginVerify(className + "." + functionName);
    		if (loginVerify != null && loginVerify) {//需要进行登录校验
    			boolean isAuthenticated = SecurityUtils.getSubject().isAuthenticated();
    			if (!isAuthenticated) {
    				String exId=requestContent.getRequest().getHead().getNWExID();
    				SystemMobileTokenKeyServiceInter systemMobileTokenKeyServiceInter = (SystemMobileTokenKeyServiceInter) SpringContextUtil
    					.getBean("systemMobileTokenKeyServiceInter");
    				SystemMobileTokenKey systemMobileTokenKey=systemMobileTokenKeyServiceInter.getByExId(exId);
    				if(systemMobileTokenKey==null)
    					throw new BaseException(ResponseCodeEnum.NO_LOGIN);
    				Date keyTime = systemMobileTokenKey.getKeyTime();
    				if (System.currentTimeMillis() - keyTime.getTime() > 1000 * 60 * 60 * 24 * 3)
    					throw new BaseException(ResponseCodeEnum.NO_LOGIN);
    			}
    		}
    		if (className == null || beanName == null || functionName == null)
    			throw new BaseException(ResponseCodeEnum.REQUEST_CODE_NOT_EXIST);
    		Object object = SpringContextUtil.getBean(beanName);
    		Class cls = Class.forName(className);
    		Method method = cls.getMethod(functionName, RequestContent.class);
    		Object response = method.invoke(object, requestContent);
    		return (ResponseContent) response;
    	}
    }

     

     

     

     

    展开全文
  • Java注解实例

    2020-03-30 23:40:55
    java注解其实就是一种配置,类似的配置方式还有xml配置,这里介绍一个简单的注解使用实例。 二、示例 public class AnnotionMain { public static void main(String[] args) throws NoSuchMethodException { //....

    Java注解实例

    一、简介

    java注解其实就是一种配置,类似的配置方式还有xml配置,这里介绍一个简单的注解使用的实例。

    二、示例

    public class AnnotionMain {
        public static void main(String[] args) throws NoSuchMethodException {
            //反射获取使用注释的方法
            Method getAppleMethod = AnnotionMain.class.getDeclaredMethod("getApple", new Class[]{String.class});
            Fruit fruitAnno = getAppleMethod.getDeclaredAnnotation(Fruit.class);  //获取注解实例
            System.out.println(fruitAnno.name());  //获取注解值
        }
    
        //注解
        @Target(ElementType.METHOD)
        @Retention(RetentionPolicy.RUNTIME)
        @interface Fruit{
            String name() default "nofruit";
        }
    
        @Fruit(name="apple")
        void getApple(String name){
            System.out.println("invoke getApple method");
        }
    }
    
    展开全文
  • JAVA 注解详解及简单实例何为注解注解(Annotation)又称为元数据,在JDK1.5后引入,它的作用是:生成文档 这是注解的原始用途,可以通过注解生成JavaDoc文档跟踪代码的依赖性 可以通过注解替代配置文件,简化项目的...

    JAVA 注解详解及简单实例

    何为注解

    注解(Annotation)又称为元数据,在JDK1.5后引入,它的作用是:

    生成文档  这是注解的原始用途,可以通过注解生成JavaDoc文档

    跟踪代码的依赖性  可以通过注解替代配置文件,简化项目的配置。现有的许多框架都采用这个功能减少自己的配置。

    编译检查  在编译时进行格式检查,例如@Override

    基础注解

    Java目前内置了三种标准注解,以及四种元注解。四种元注解负责创建其他的注解。

    三种标准注解

    @Override,表示当前的方法覆盖超类中的方法

    @Deprecated,如果程序员使用被这个注解注释的元素,则编译器会进行提示

    @Suppress Warnings,忽略编译器的警告

    四种元注解

    @Target,表示注解的适用范围,例如@Target(ElementType.FIELD).

    ElementType的枚举值有

    CONSTRUCTOR,用于构造方法

    FIELD,用于字段声明,包括常量

    LOCAL_VARIABLE,用于局部变量

    METHOD,用于方法

    PACKAGE,用于包声明

    PARAMETER,用于参数声明

    TYPE,用于类,接口

    @Retention,表示注解的保留级别,例如@Retention(RetentionPolicy.RUNTIME).

    RetentionPolicy的枚举值有

    Source,注解将被编译器丢弃

    Class,注解可以在class文件中使用,但是会被VM丢弃

    Runtime,在VM的运行期间也会保留

    @Document,将次注解在javaDoc文件中可见

    @Inherited,允许子类继承父类中的注解

    自定义注解

    创建注解

    @interface标明该类型是一个注解的定义

    对于“String method() default "dong something";”来说String是注解参数的数据类型,method是参数名,default用来设置默认值

    注解的使用

    注解使用的格式为"@Annotation(para=xxxx,...)",Annotation是注解名,para是注解中设置的参数名,参数如果不设置值,则会使用默认值

    设置注解解析器

    输出结果为

    通过反射机制,遍历方法,然后获取方法的注解。注解可以注解类,方法,字段等等,所以也可以通过类似的方式获取这些对象的注解,然后进行处理。

    感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    原文链接:https://my.oschina.net/u/241670/blog/874904

    展开全文
  • Java自定义注解实例

    2017-11-03 17:24:30
    包括Java自定义注解以及包括自定义注解的应用实例。以及注解相关知识的注解
  • 主要介绍了Java注解处理器简单实例,具有一定借鉴价值,需要的朋友可以参考下
  •  注解的语法比较简单,除了@符号的使用之外,它基本与Java固有语法一致。Java SE5内置了三种标准注解:  @Override,表示当前的方法定义将覆盖超类中的方法。  @Deprecated,使用注解为它的元素编译器将...
  • 主要介绍了java注解annotation使用方法,注解可以定义到方法上,类上,一个注解相当与一个类,就相当于实例了一个对象,加上了注解,就相当于加了一个标志
  • 1、注解的定义 import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * 创建时间:2015-7-...
  • java 注解实例

    千次阅读 2017-01-28 22:17:03
    这里介绍诸如@Override、@Test的注解是如何实现(实例化)的? 其实注解是一个被final修饰、继承Annotation的interface。 不过既然是interface,那么就不能直接实例化,但是却可以通过getAnnotation(Class)方法取得...
  • java注解研究实例

    2012-04-11 17:52:48
    注解(Annotation) 为我们在代码中天界信息提供了一种形式化的方法,是我们可以在稍后 某个时刻方便地使用这些数据...定义一个注解 MyAnnotationClassDefinition.java package org.lsy.test.little; import jav
  • java自定义注解实例

    2017-03-24 08:23:57
    java自定义注解实例@(Java) 通过前两篇文章,初步了解了java注解后,在这一篇中,将实现自己的自定义注解。 前两篇文章详细见: java注解及源码浅析 java内建注解及源码浅析为什么要使用自定义注解?刚开始...
  • 创建注解 /** * 注释表名称 */ @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Table { public String name() default ""; } /** * 注释表的字段名 */ @...
  • java注解简单实例

    2015-08-10 10:49:00
    1、创建一个注解 package com.anno; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation....
  • 阿里开发手册:Java注释规范实例
  • 主要介绍了JAVA 注解详解及简单实例的相关资料,需要的朋友可以参考下
  • java注解使用例子

    2019-04-08 01:33:46
    NULL 博文链接:https://smallbee.iteye.com/blog/1611962
  • 关于Java 注解的简介与使用
  • Java 注解入门实例 && 注解传参

    万次阅读 2015-08-01 19:34:41
    概念:java提供了一种原程序中的元素关联任何信息和任何元数据的途径和方法 JDK内置系统注解: @Override 用于修饰此方法覆盖了父类的方法; @Deprecated 用于修饰已经过时的方法; @Suppvisewarnings 用于通知...
  • java注解入门实例

    2012-10-30 17:02:00
    原文:http://www.java3z.com/cwbwebhome/article/article8/81319.html?id=3239 注解(Annotation) 为我们在代码中添加...注解的语法比较简单,除了@符号的使用以外,它基本上与java的固有语法一致,java内置了...
  • Java注解入门实例

    2011-01-13 16:18:00
    // Test.java package userDefined; import java.lang.annotation.Documented; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation....
  • 秒懂,Java 注解 (Annotation)你可以这样学

    万次阅读 多人点赞 2017-06-27 21:48:30
    文章开头先引入一处...Annotation 中文译过来就是注解、标释的意思,在 Java注解是一个很重要的知识点,但经常还是有点让新手不容易理解。 我个人认为,比较糟糕的技术文档主要特征之一就是:用专业名词来...
  • java自定义注解实例

    2019-07-31 17:49:15
    java自定义注解实例目录说明项目结构注解定义自定义表注解@Table>>Table.java自定义字段注解@Field>>Field.java实体类User.java测试方法dao_text.java总结 目录 说明 内容主要是如何自定义注解(可以...
  • java 注解实例

    2014-07-23 10:41:28
    Java中的注解机制 注解(Annotation) 为我们在代码中添加信息... 注解的语法比较简单,除了@符号的使用以外,它基本上与java的固有语法一致,java内置了三种 注解,定义在java.lang包中。  @Overrid
  • 主要介绍了java 自定义注解实例详解的相关资料,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 377,889
精华内容 151,155
关键字:

java注解使用案例

java 订阅