精华内容
下载资源
问答
  • java注解传入变量
    2021-03-09 20:45:28

    介绍

    本文将讨论用Java创建注解的方法。还有如何将注解应用于其他声明。最后,讨论一下如何在运行时使用Reflection获得注解信息。

    背景

    注解是J2SE 5引入的一项新功能,允许程序员将称为元数据的其他信息嵌入Java源文件中。注解不会改变程序的执行,但是在开发和部署期间,各种工具都可以使用使用注解嵌入的信息。

    使用代码

    创建注解与创建接口相似。只不过注解声明前面有一个@符号。注解声明本身使用注解进行@Retention注解。该@Retention注解用于指定保留策略,可以是SOURCE,CLASS或RUNTIME。

    RetentionPolicy.SOURCE 仅在源文件中保留注解,并在编译期间将其丢弃。RetentionPolicy.CLASS将注解存储在.class文件中,但在运行时不可用。RetentionPolicy.RUNTIME将注解存储在.class文件中,并使其在运行时可用。

    注解会隐式扩展Annotation接口。注解的主体由不带主体的方法声明组成。这些方法像字段一样工作。

    在上面的例子中,我已经创建了两个部件,author并date以表示关于创建者的信息,并且类和方法的写入日期。

    创建注解后,可以将其应用于类,方法,字段,参数,枚举等。在对声明应用注解时,必须为其成员提供如下值:

    可以在运行时使用Reflection来查询注解,如下所示:

    在上面的代码中,我查询了应用于类Test以及method的注解testMethod()。

    要获取该类的注解信息,请使用以下语句:

    要获取该方法的注解信息,请使用以下语句:

    通过使用注解对象来打印注解信息。

    问题:注解声明后,在运行期如何查询它的信息?

    答:使用Reflection来查询注解

    ————END————

    点赞(编辑不易,感谢您的支持)

    ...

    转发(分享知识,传播快乐)

    ...

    关注(每天更新Java开发技术)

    ...

    更多相关内容
  • java注解的使用

    千次阅读 2021-02-28 12:43:27
    java注解的使用1.说再前面使用注解开发的好处1.使代码更加干净易读,易于维护修改。比如,以前使用spring的开发,都是基于xml文件实现了统一的配置管理,但是缺点也是显而易见的,就是随着项目的越来越大,xml文件...

    java中注解的使用

    1.说再前面

    使用注解开发的好处

    1.使代码更加干净易读,易于维护修改。比如,以前使用spring的开发,都是基于xml文件实现了统一的配置管理,但是缺点也是显而易见的,就是随着项目的越来越大,xml文件会变得越来越复杂,维护成本也会越来越高。使用注解就可以提供更大的便捷性,易于维护修改。

    2 可以实现代码的类型检查,特别是在编译器的角度实现一些类型检查,比如预检查(@Override)和抑制警告(@SuppressWarnings)等。

    3 自定义注解,作为额外信息的载体,存储有关程序的额外信息

    2 注解的分类以及使用

    ​ Java注解是附加在代码中的一些元信息,用于编译和运行时进行解析和使用,起到说明、配置的功能。

    注解不会影响代码的实际逻辑,仅仅起到辅助性的作用。包含在java.lang.annotation包中。注解的定义类似于接口的定义,使用@interface来定义,定义一个方法即为注解类型定义了一个元素,方法的声明不允许有参数或throw语句,返回值类型被限定为原始数据类型、字符串String、Class、enums、注解类型,或前面这些的数组,方法可以有默认值。注解并不直接影响代码的语义,但是他可以被看做是程序的工具或者类库。它会反过来对正在运行的程序语义有所影响。注解可以从源文件、class文件或者在运行时通过反射机制多种方式被读取。

    一般来说,注解一般分为三种类型: 元注解,标准注解,自定义注解

    2.1 元注解

    元注解是专职负责注解其他注解,主要是标明该注解的使用范围,生效范围。我们是不能改变它的,只能用它来定义我们自定义的注解。

    包括 @Retention @Target @Document @Inherited四种。(java.lang.annotation中提供,为注释类型)。

    注解

    说明

    @Target

    定义注解的作用目标,也就是可以定义注解具体作用在类上,方法上,还是变量上

    @Retention

    定义注解的保留策略。RetentionPolicy.SOURCE:注解仅存在于源码中,在class字节码文件中不包含;RetentionPolicy.CLASS:默认的保留策略,注解会在class字节码文件中存在,但运行时无法获得;RetentionPolicy.RUNTIME:注解会在class字节码文件中存在,在运行时可以通过反射获取到。

    @Document

    说明该注解将被包含在javadoc中

    @Inherited

    说明子类可以继承父类中的该注解

    Target类型主要依赖于ElementType这个类型,具体的类型如下:

    Target类型

    说明

    ElementType.TYPE

    接口、类、枚举、注解

    ElementType.FIELD

    字段、枚举的常量

    ElementType.METHOD

    方法

    ElementType.PARAMETER

    方法参数

    ElementType.CONSTRUCTOR

    构造函数

    ElementType.LOCAL_VARIABLE

    局部变量

    ElementType.ANNOTATION_TYPE

    注解

    ElementType.PACKAGE

    2.2 标准注解

    Java标准注解提供了三个,定义在java.lang中的注解,我认为这三个注解的作用更多的是一种注释

    @Override 表示当前方法覆盖父类中的方法。

    @Deprecated 标记一个元素为已过期,避免使用

    支持的元素类型为:CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE

    @SuppressWarnings 不输出对应的编译警告

    一个简单的使用demo:

    @SuppressWarnings(value = {"unused", "rawtypes"})

    public class Children extends Parent{

    @Override

    public void work() {

    System.out.println("我是一个被重写的方法");

    }

    @Deprecated

    public void play(){

    System.out.println("这个方法不推荐使用了");

    }

    }

    2.3 自定义注解实现一个sql语句的拼接

    需要注意的方面:注解的定义类似于接口的定义,使用@interface来定义,定义一个方法即为注解类型定义了一个元素,方法的声明不允许有参数或throw语句,返回值类型被限定为原始数据类型、字符串String、Class、enums、注解类型,或前面这些的数组,方法可以有默认值。

    自定义注解一般可以分为三步: 定义注解,使用注解,读取注解

    定义注解

    @Target(ElementType.TYPE) //注解加载类上

    @Retention(RetentionPolicy.RUNTIME) // 运行时读取注解

    public @interface Table {

    String value();

    }

    @Target(ElementType.FIELD)

    @Retention(RetentionPolicy.RUNTIME)

    public@interface UserFiled {

    String name();

    String type();

    int length();

    }

    使用注解

    // 将自定义的注解加在用户上,实现一个表的映射

    @Table(value = "user_table")

    public class User {

    @UserFiled(name = "user_id",type = "int",length = 8)

    private int userId;

    @UserFiled(name = "user_name",type = "varchar",length = 16)

    private String userName;

    @UserFiled(name = "password",type = "varchar",length = 16)

    private String password;

    public int getUserId() {

    return userId;

    }

    public void setUserId(int userId) {

    this.userId = userId;

    }

    public String getUserName() {

    return userName;

    }

    public void setUserName(String userName) {

    this.userName = userName;

    }

    public String getPassword() {

    return password;

    }

    public void setPassword(String password) {

    this.password = password;

    }

    }

    读取注解的内容

    /**

    * 读取注解中的值

    */

    public class GetUser {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {

    Class userClass = Class.forName("annocation.blog.User");

    // 读取类上的注解

    Table table = (Table) userClass.getAnnotation(Table.class);

    System.out.println(table.value());

    // 读取属性上注解

    Field userId = userClass.getDeclaredField("userId");

    UserFiled userFiledId = userId.getAnnotation(UserFiled.class);

    System.out.println(userFiledId.length() + "----" + userFiledId.type() + "-----" + userFiledId.name());

    Field userName = userClass.getDeclaredField("userName");

    UserFiled userFiledName = userName.getAnnotation(UserFiled.class);

    System.out.println(userFiledName.length()+"----"+userFiledName.type()+"----"+userFiledName.name());

    Field password = userClass.getDeclaredField("password");

    UserFiled userFiledPassword = password.getAnnotation(UserFiled.class);

    System.out.println(userFiledPassword.name() + "-----" + userFiledPassword.type() + "-----" + userFiledPassword.length());

    // 拼接一个sql语句

    String name = "chenwei";

    String sql ="select * from" + table.value()+"where"+userFiledName.name()+"="+name;

    }

    }

    结果:

    user_table

    user_id----int-----8

    user_name----varchar----16

    password-----varchar-----16

    自定义注解的实现过程:

    1,定义注解

    2,使用注解,根据自己定义的注解来达到一些目的,本例中,就是使用注解来完成数据库表和实体类的映射关系

    3 读取注解的内容,也是比较重要的一部分,核心还是利用了反射的思想,得到使用注解的这个类,根据类中的getAnnotion的方法得到定义的注解,获得注解上的值。

    3 注解的实现的原理

    注解的实现的原理很大的一部分是基于反射实现。

    ​ 反射可以获取到Class对象,进而获取到Constructor、Field、Method等实例,点开源码结构发现Class、Constructor、Field、Method等均实现了AnnotatedElement接口,AnnotatedElement接口的方法如下

    // 判断该元素是否包含指定注解,包含则返回true

    boolean isAnnotationPresent(Class extends Annotation> annotationClass)

    // 返回该元素上对应的注解,如果没有返回null

    T getAnnotation(Class annotationClass);

    // 返回该元素上的所有注解,如果没有任何注解则返回一个空数组

    Annotation[] getAnnotations();

    // 返回指定类型的注解,如果没有返回空数组

    T[] getAnnotationsByType(Class annotationClass)

    // 返回指定类型的注解,如果没有返回空数组,只包含直接标注的注解,不包含inherited的注解

    T getDeclaredAnnotation(Class annotationClass)

    // 返回指定类型的注解,如果没有返回空数组,只包含直接标注的注解,不包含inherited的注解

    T[] getDeclaredAnnotationsByType

    // 返回该元素上的所有注解,如果没有任何注解则返回一个空数组,只包含直接标注的注解,不包含inherited的注解

    Annotation[] getDeclaredAnnotations();

    通过一个实例再次说明一下注解的使用过程:

    定义注解

    @Documented

    @Target({ElementType.TYPE, ElementType.FIELD,ElementType.METHOD})

    @Retention(RetentionPolicy.RUNTIME)

    public @interface MyAnnotaion {

    String getValue() default "this is myAnntaion";

    int order() default 0;

    }

    使用注解

    @MyAnnotaion(getValue = "annotation on class")

    public class Demo {

    @MyAnnotaion(getValue = "annotation on filed")

    public String name;

    @MyAnnotaion(getValue = "annotation on method")

    public void hello(){

    }

    @MyAnnotaion

    public void defaultMethod(){

    }

    }

    利用反射读取注解中的值。

    public class TestDemo {

    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException {

    /**

    * 获取类上的注解

    */

    Class demoClass = Demo.class;

    Annotation[] annotaion = demoClass.getAnnotations();

    printAnnotation(annotaion);

    /**

    * 读取成员变量上的注解

    */

    Field name = demoClass.getField("name");

    Annotation[] getOnFiled = name.getAnnotations();

    printAnnotation(getOnFiled);

    /**

    * 读取方法上的注解

    */

    Method hello = demoClass.getMethod("hello", null);

    MyAnnotaion onMethod = hello.getAnnotation(MyAnnotaion.class);

    System.out.println(onMethod.getValue());

    /**

    * 获取默认方法上的注解

    */

    Method defaultMethod = demoClass.getMethod("defaultMethod", null);

    MyAnnotaion onDefaultMethod = defaultMethod.getAnnotation(MyAnnotaion.class);

    System.out.println(onDefaultMethod.getValue());

    }

    public static void printAnnotation(Annotation... annotations) {

    for (Annotation annotation : annotations) {

    System.out.println(annotation);

    }

    }

    }

    运行结果

    @annocation.MyAnnotaion(getValue=annotation on class, order=0)

    @annocation.MyAnnotaion(getValue=annotation on filed, order=0)

    annotation on method

    this is myAnntaion

    参考资料:

    《java编程思想》

    展开全文
  • Java 注解入门实例 && 注解传参

    千次阅读 2021-04-17 06:45:03
    参考概念:java提供了一种原程序中的元素关联任何信息和任何元数据的途径和方法JDK内置系统注解:@Override 用于修饰此方法覆盖了父类的方法;@Deprecated 用于修饰已经过时的方法;@Suppvisewarnings 用于通知java...

    参考

    概念:java提供了一种原程序中的元素关联任何信息和任何元数据的途径和方法

    JDK内置系统注解:

    @Override 用于修饰此方法覆盖了父类的方法;

    @Deprecated 用于修饰已经过时的方法;

    @Suppvisewarnings 用于通知java编译器禁止特定的编译警告。

    00a44fd6b948595278d222ef8a7bd42b.png

    注解按照运行机制划分

    源码注解:注解只在源码中存在,编译成.class文件就不存在了;

    编译时注解:注解在源码和.class文件中都存在(例:JDK自带注解);

    运行时注解:在运行阶段还起作用,甚至会影响运行逻辑的注解(Autowired);

    自定义注解的元注解:

    @Target—作用域(constructor(构造方法声明),field(字段声明),local_variable(局部变量声明),method(方法声明),package(包声明),parameter(参数声明),type(类,接口声明))

    @Retention—生命周期(source:只在源码显示,编译时会丢弃。class:编译时会记录到class中,运行时忽略。runtime:运行时存在,可以通过反射读取)

    Inherited—标识注解(允许子类继承)

    Documented—生成Javadoc

    若成员只有一个,必须为value,这个参数赋值可以不写value=XXX

    b8c95255bec6a14b5280cdf045f0f92c.png

    44d06353a80eafffbb208f82a9cc9b60.png

    成员以无参无异常方式声明。成员类型是受限的,合法的类型包括原始类型及String,Class,Annotation, Enumeration.

    上面用了注解,程序中获得注解信息的方法是反射。

    Class cls = Class.forName(“”);//使用类加载器加载类

    cls.isAnnotationPresent(xx.class);//判断cls这个类上是否有xx的注解,找到类上注解

    xx a = (xx)cls.getAnnotation(xx.class);//取得其上的注解

    下面附一个实例,是框架如何使用注解描述参数。

    结构图

    cc506aab8c089e1b996e2ecd530410f2.png

    A.java

    package javaBasic;

    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;

    @Target({ElementType.PARAMETER ,ElementType.METHOD})

    @Retention(RetentionPolicy.RUNTIME)

    @Documented

    public @interface A {

    String value();

    String name() default "bingone";

    int age() default 20;

    }

    B.java

    package javaBasic;

    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;

    @Target({ElementType.PARAMETER ,ElementType.METHOD})

    @Retention(RetentionPolicy.RUNTIME)

    @Documented

    public @interface B {

    String value();

    String name() default "bingone";

    }

    DataClass.java

    package javaBasic;

    public class DataClass {

    public String name;

    public int age;

    public DataClass(String name, int age) {

    super();

    this.name = name;

    this.age = age;

    }

    }

    RunClass.java

    package javaBasic;

    public class RunClass {

    public static void run(@A("str") String str,@B("age")int age){

    System.out.println("In run Method str:" + str + "age:" + age);

    }

    }

    TestClass.java

    package javaBasic;

    import java.io.FileNotFoundException;

    import java.io.IOException;

    import java.lang.annotation.Annotation;

    import java.lang.reflect.Method;

    /**

    * 通过注解传参数

    *@author gg_gogoing

    *

    */

    public class TestClass {

    public static void parseMethod(DataClass data,Object obj,String mthname){

    //验证是否有注解

    //若有则两种方法:

    //1. 在编译时刻已经有了对应的表,查表即可

    //2. 如下的遍历方式。

    if(obj instanceof RunClass){

    String str = null;

    int age = 0;

    Method [] methods = (Method[])obj.getClass().getMethods();

    for(Method method :methods){

    if(method.getName().equals(mthname)){

    Annotation[][] annotations = method.getParameterAnnotations();

    for(Annotation[] tt : annotations){

    for(Annotation t:tt){

    if(t instanceof A){

    str = data.name;

    }else if(t instanceof B){

    age = data.age;

    }

    }

    }

    RunClass.run(str, age);

    }

    }

    }

    }

    public static void main(String[] args) throws Exception, RuntimeException { // 主方法

    //不直接传参数,而是将一个类中的数据传入

    DataClass dc = new DataClass("gg_gogoing", 20);

    parseMethod(dc, new RunClass(), "run");

    }

    }

    eff40bc5224288efc4c3c134d50a7c90.png

    展开全文
  • 现在是写了个通用controller,然后用shiro做权限校验,结果突然发现每个controller方法中requirepermissions注解的权限路径不一致,需在通用controller使用requirepermissions注解中并传入获取泛型名称的变量值 ...
  • 主要介绍了Java参数传递及值传递实现原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 1 元注解1.1 什么是元注解所谓元注解其实就是可以注解到别的注解上的注解,被注解注解称之为组合注解,组合注解具备其上元注解的功能.1.2 四种元注解在JDK中提供了4个标准的用来对注解类型进行注解注解类,我们称...

    1 元注解

    1.1 什么是元注解

    所谓元注解其实就是可以注解到别的注解上的注解,被注解的注解称之为组合注解,组合注解具备其上元注解的功能.

    1.2 四种元注解

    在JDK中提供了4个标准的用来对注解类型进行注解的注解类,我们称之为 meta-annotation(元注解),他们分别是:

    @Target

    @Retention

    @Documented

    @Inherited

    我们可以使用这4个元注解来对我们自定义的注解类型进行注解.

    1.3 @Target注解

    Target注解的作用是:描述注解的使用范围(即被修饰的注解可以用在什么地方).

    Target注解用来说明那些被它所注解的注解类可修饰的对象范围:注解可以用于修饰 packages、types(类、接口、枚举、注解类)、类成员(方法、构造方法、成员变量、枚举值)、方法参数和本地变量(如循环变量、catch参数),在定义注解类时使用了@Target 能够更加清晰的知道它能够被用来修饰哪些对象,它的取值范围定义在ElementType 枚举中.

    源码

    @Documented

    @Retention(RetentionPolicy.RUNTIME)

    @Target(ElementType.ANNOTATION_TYPE)

    public @interface Target {

    ElementType[] value();

    }

    ElementType

    public enum ElementType {

    TYPE, // 类、接口、枚举类

    FIELD, // 成员变量(包括:枚举常量)

    METHOD, // 成员方法

    PARAMETER, // 方法参数

    CONSTRUCTOR, // 构造方法

    LOCAL_VARIABLE, // 局部变量

    ANNOTATION_TYPE, // 注解类

    PACKAGE, // 可用于修饰:包

    TYPE_PARAMETER, // 类型参数,JDK 1.8 新增

    TYPE_USE // 使用类型的任何地方,JDK 1.8 新增

    }

    1.4 @Retention

    Reteniton注解的作用是:描述注解保留的时间范围(即:被描述的注解在它所修饰的类中可以被保留到何时).

    Reteniton注解用来限定那些被它所注解的注解类在注解到其他类上以后,可被保留到何时,一共有三种策略,定义在RetentionPolicy枚举中.

    RetentionPolicy

    public enum RetentionPolicy {

    SOURCE, // 源文件保留

    CLASS, // 编译期保留,默认值

    RUNTIME // 运行期保留,可通过反射去获取注解信息

    }

    生命周期长度 SOURCE < CLASS < RUNTIME ,前者能作用的地方后者一定也能作用。如果需要在运行时去动态获取注解信息,那只能用 RUNTIME 注解;如果要在编译时进行一些预处理操作,比如生成一些辅助代码(如 ButterKnife),就用 CLASS注解;如果只是做一些检查性的操作,比如 @Override 和 @SuppressWarnings,则可选用 SOURCE 注解。

    1.5 @Documented

    Documented注解的作用是:描述在使用 javadoc 工具为类生成帮助文档时是否要保留其注解信息。

    这里验证@Documented的作用,我们创建一个自定义注解:

    @Documented

    @Target({ElementType.TYPE,ElementType.METHOD})

    public @interface MyDocumentedt {

    public String value() default "这是@Documented注解为文档添加的注释";

    }

    然后创建一个测试类,在方法和类上都加入自定义的注解

    @MyDocumentedt

    public class MyDocumentedTest {

    /**

    * 测试 document

    * @return String the response

    */

    @MyDocumentedt

    public String test(){

    return "sdfadsf";

    }

    }

    打开java文件所在的目录下,打开命令行输入:

    javac .\MyDocumentedt.java .\MyDocumentedTest.java

    javadoc -d doc .\MyDocumentedTest.java .\MyDocumentedt.java

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    打开生成的doc文件夹,打开index.html,可以发现在类和方法上都保留了 MyDocumentedt 注解信息。

    1.6 @Inherited

    Inherited注解的作用是:使被它修饰的注解具有继承性(如果某个类使用了被@Inherited修饰的注解,则其子类将自动具有该注解)。

    通过代码来进行验证,创建一个自定义注解

    @Target({ElementType.TYPE})

    @Inherited

    @Retention(RetentionPolicy.RUNTIME)

    public @interface MyInherited {

    }

    验证

    @MyInherited

    public class A {

    public static void main(String[] args) {

    System.out.println(A.class.getAnnotation(MyInherited.class));

    System.out.println(B.class.getAnnotation(MyInherited.class));

    System.out.println(C.class.getAnnotation(MyInherited.class));

    }

    }

    class B extends A{

    }

    class C extends B{

    }

    执行main方法,从控制台中可以看到打印的信息

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    1.7 重复注解 @Repeatable

    重复注解:即允许在同一申明类型(类,属性,或方法)前多次使用同一个类型注解。

    在java8 以前,同一个程序元素前最多只能有一个相同类型的注解;如果需要在同一个元素前使用多个相同类型的注解,则必须使用注解“容器”。

    java8之前的做法

    public @interface Roles {

    Role[] roles();

    }

    public @interface Roles {

    Role[] value();

    }

    public class RoleAnnoTest {

    @Roles(roles = {@Role(roleName = "role1"), @Role(roleName = "role2")})

    public String doString(){

    return "";

    }

    }

    java8之后增加了重复注解,使用方式如下:

    public @interface Roles {

    Role[] value();

    }

    @Repeatable(Roles.class)

    public @interface Role {

    String roleName();

    }

    public class RoleAnnoTest {

    @Role(roleName = "role1")

    @Role(roleName = "role2")

    public String doString(){

    return "";

    }

    }

    不同的地方是,创建重复注解 Role 时,加上@Repeatable,指向存储注解 Roles,在使用时候,直接可以重复使用 Role 注解。从上面例子看出,java 8里面做法更适合常规的思维,可读性强一点。但是,仍然需要定义容器注解。

    两种方法获得的效果相同。重复注解只是一种简化写法,这种简化写法是一种假象:多个重复注解其实会被作为“容器”注解的 value 成员的数组元素处理。

    1.8 类型注解

    Java8 为 ElementType 枚举增加了TYPE_PARAMETER、TYPE_USE两个枚举值,从而可以使用 @Target(ElementType_TYPE_USE) 修饰注解定义,这种注解被称为类型注解,可以用在任何使用到类型的地方。

    在 java8 以前,注解只能用在各种程序元素(定义类、定义接口、定义方法、定义成员变量…)上。从 java8 开始,类型注解可以用在任何使用到类型的地方。

    TYPE_PARAMETER:表示该注解能写在类型参数的声明语句中。

    TYPE_USE:表示注解可以再任何用到类型的地方使用,比如允许在如下位置使用:

    创建对象(用 new 关键字创建)

    类型转换

    使用 implements 实现接口

    使用 throws 声明抛出异常

    public class TypeUserTest {

    public static void main(String[] args) {

    String str = "str";

    Object obj = (@isNotNull Object) str;

    }

    }

    @Target(ElementType.TYPE_USE)

    @interface isNotNull{

    }

    这种无处不在的注解,可以让编译器执行更严格的代码检查,从而提高程序的健壮性。

    2 自定义注解

    通过上面的学习已经初步了解了元注解是怎么一回事,下面撸一个自定义注解来融会贯通.

    自定义注解

    @Retention(RetentionPolicy.RUNTIME)

    @Target(ElementType.FIELD)

    public @interface Name {

    public String value() default "";

    }

    @Retention(RetentionPolicy.RUNTIME)

    @Target(ElementType.FIELD)

    public @interface Sex {

    public enum GenderType {

    Male("男"),

    Female("女");

    private String genderStr;

    private GenderType(String arg0) {

    this.genderStr = arg0;

    }

    @Override

    public String toString() {

    return genderStr;

    }

    }

    GenderType gender() default GenderType.Male;

    }

    使用自定义注解的实体类

    @Data

    public class User {

    @Name(value = "wtj")

    public String name;

    public String age;

    @Sex(gender = Sex.GenderType.Male)

    public String sex;

    }

    测试

    public class AnnotionUtils {

    public static String getInfo(Class> cs){

    String result = "";

    //通过反射获取所有声明的字段

    Field[] declaredFields = cs.getDeclaredFields();

    //获取所有字段

    for (Field field : declaredFields){

    if(field.isAnnotationPresent(Name.class)){

    //获取程序元素上的注解

    Name annotation = field.getAnnotation(Name.class);

    String value = annotation.value();

    result += (field.getName() + ":" + value + "\n");

    }

    if(field.isAnnotationPresent(Sex.class)){

    Sex annotation = field.getAnnotation(Sex.class);

    String value = annotation.gender().name();

    result += (field.getName() + ":" + value + "\n");

    }

    }

    return result;

    }

    public static void main(String[] args){

    String info = getInfo(User.class);

    System.out.println(info);

    }

    }

    main方法运行后就可以在控制台中看到使用注解时传入的数据了.

    上面就是一个简单的注解使用的demo,当然,在实际工作中使用的会相对复杂,这就需要我们根据业务需求及代码需求进行封装和使用自定义注解了.

    展开全文
  • Java注解

    2021-09-11 16:08:04
    Java注解 Java 注解(Annotation)又称 Java 标注,是 JDK5.0 引入的一种注释机制。 Java 语言中的类、方法、变量、参数和包等都可以被标注。和 Javadoc 不同,Java 标注可以通过反射获取标注内容。在编译器生成类...
  • 而在开发Java程序之前,通常需要先在Windows操作系统中配置好有关Java的系统环境变量(Environment Variable)。 在介绍环境变量的含义之前,我们先举一个形象的例子,给读者一个感性的认识。比如我们喊一句:“张三...
  • java中的全局变量

    千次阅读 2021-03-18 08:12:03
    正在使用NetBeans做一个稍大点的程序,刚刚学习使用,感觉程序中需要用到全局变量(其实java中是没有全局变量这个概念的)。在网上查了不少的资料,得到一点点体会:首先,java中是没有全局变量这个概念的,java程序中...
  • 下面小编就为大家带来一篇java自定义注解实现前后台参数校验的实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了深入理解Java注解类型(@Annotation),小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 【求助】怎么动态给Java注解参数赋值呢? 比如使用如下注解的时候: @SensitiveInfo(type = "String",isEffictive = false) isEffictive的值如何动态传入,能传入一个变量吗? 百度贴吧也有一个类似的帖子 ...
  • JAVA 继承变量 08

    2021-10-12 11:47:20
    1.继承中变量的使用 如果父类的成员变量与子类的成员变量同名时,使用super.变量名指定父类的成员变量 2.继承中构造方法的使用 我们每次创建对象的时候,都会先触发构造函数 创建子类对象时,会先调用父类的无参...
  • java注解 - Mr.yang.localhost - 博客园

    千次阅读 2021-02-28 09:09:48
    注解使用Java注解是附加在代码中的一些元信息,用于一些工具在编译、运行时进行解析和使用,起到说明、配置的功能。注解不会也不能影响代码的实际逻辑,仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。元...
  • Java 注解

    2021-02-28 16:01:23
    极大程度地简化了代码,提高了代码的可读性注解的概述Java提供了一种源程序中元素和任何信息或者元数据相关联的一种方法或者渠道源程序中元素: Java文件 构造方法、成员变量、成员方法...信息:...
  • 1、java中的变量与数据类型 2、思考 3、例子: 3.1、分析: 3.2、结论 1、java中的变量与数据类型 变量是一个容器,用来装什么的呢?装内存地址,这个内存地址对应的是内存中某个数据。 那为什么这个容器不...
  • 变量赋值和参数传递是java中两个容易让人迷惑的问题。对于原始类型(primitives type),java采用值传递,这很明显。然而,当传递的参数类型是对象时,或者两个对象的变量进行赋值时,问题就有些复杂,很多初学者对此...
  • Java-注解

    千次阅读 2022-04-08 15:20:51
    java注解可以说是java框架的灵魂了
  • JAVA中的元注解 什么是元注解?元注解就是对其他普通注解进行说明解释的注解java中定义了4个元注解,自动继承了java.lang.annotation.Annotation @Target @Target限定了一个注解的使用范围,作用域,默认可以在...
  • 主要介绍了java注解机制及其原理的详解的相关资料,希望通过本文能帮助到大家,让大家理解掌握这部分内容,需要的朋友可以参考下
  • java 注解详细使用

    2021-08-06 13:56:10
    注解(重点) 注解的基本概念 注解(Annotation)又叫标注,是从Java5开始增加的...通过@注解名称的方式可以修饰包、类、 成员方法、成员变量、构造方 法、参数、局部变量的声明等 注解的使用方式 注解体中只有成员
  • java 注解 关键字相关

    2021-06-11 14:15:03
    java注解、关键字final部分注解 final private final (后续只可读取不可修改) final在Java中意思类似于“不可修改的”,可以在声明类、变量或者方法的时候使用。 如果一个类被声明为final,则这个类将不会有子类,...
  • 深入浅出Java注解

    千次阅读 2021-03-22 12:26:05
    什么是注解注解对于开发人员来讲既熟悉又陌生,熟悉是因为只要你是做开发,都会用到注解(常见的@Override);陌生是因为即使不使用注解也照常能够进行开发;...Java注解又称为标注,是Java从1.5开始支持加...
  • 文章目录一、@PathVariable二、@RequestHeader三、@RequestBody四、@...功能:用于访问URI模板变量。 案例 controller层代码 @ResponseBody @GetMapping("/demo01/{id}/{name}") public String testPathVariabl
  • 从JDK1.5开始,Java提供了对元数据(MetaData)的支持,也就是注解(Annotation) 注解,其实就是代码中的特殊标记,这些特殊标记可以在类加载,编译,运行时被读取,并执行相应的处理 使用注解最大的作用就是在不改变程序原...
  • 文章目录1. 简介2. 元注解3. 标准注解4. 获取注解的值5. 自定义注解处理器1. 自定义注解环境配置2. 自定义注解处理器3....1. 简介 Annontation是Java5开始引入的新特征,中文名称叫注解。...Java注解包含在ja

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 90,793
精华内容 36,317
关键字:

java注解传入变量

友情链接: BreakOutha.rar