Java注解和反射

最新推荐文章于 2024-05-16 20:42:16 发布
最新推荐文章于 2024-05-16 20:42:16 发布
阅读量137 收藏 1
点赞数 1
分类专栏： Java 文章标签： java jvm 反射 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxh1996/article/details/119066030
版权

Java注解和反射

1.注解

  • 注解(Annotation)从JDK5.0引入，不是程序本身，可以对程序作出解释（和注释(comment)一样），但可以被其他程序（如编译器）读取
  • Annotation格式："@注释名"，可以添加一些参数值
  • 使用：可以附加在package,class,method,field等上面，相当于添加额外的辅助信息，通过反射机制编程实现对这些元数据的访问。

1.1 内置注解

  1. @override: 定义在java.lang.Override中，只适用修辞方法，表示该方法重写超类中的一个方法
  2. @Deprecated:java.lang.Deprecated,表示修饰的方法，属性，类已过时，推荐适用另外的
  3. @SuppressWarnings:抑制编译时的警告信息，需要添加参数。如@SSuppressWarnings(“all”),SuppressWarnings(“unchecked”)等。

1.2 元注解

元注解的作用就是负责注解其他注解，java定义了4个标准的meta-annotation类型，被用来提供对其他annotation类型作说明。在java.lang.annotation包中可以找到。

  1. @Target:用于描述注解的使用范围（即：被描述的注解可以用在什么地方）
  2. @Retention:表示需要在什么级别保存该注释信息，用于描述注解的生命周期（SOURCE < CLASS < RUNTIME)
  3. @Document:说明该注解被包含在javadoc中
  4. @Inherited:说明子类可以继承父类中的该注解

1.3 自定义注解

使用@interface自定义注解，且自动继承java.lang.annotation.Annotation接口

  1. 注解声明格式：public @interface 注解名 {定义内容}
  2. 其中的每一个方法实际是声明一个配置参数
  3. 方法名称就是参数名称
  4. 通过default声明默认参数值
  5. 一个参数成员，一般参数名为value
  6. 注解元素必须要有值，可以使用空字符串，0为默认值
//自定义注解
public class Test02 {
    //注解可以显示赋值，如果没有默认值，必须给注解赋值
    @MyAnnotation2(name = "ann1")
    public void test() {}

    @MyAnnotation3("mianmianmi")
    public void test2(){}
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    //注解的参数：参数类型 + 参数名（）;
    String name() default "";
    int age() default 0;
    int id() default -1; //默认值为-1，代表不存在

    String[] schools() default {"西北","西南","东北"};
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    String value();//只有一个参数，使用value命名
}

2.反射

静态语言（java,c,c++)和动态语言(C#,JavaScript,PHP):根据运行时结构是否可变区分，如引入新的函数、对象，删除已有的函数等，即代码运行时可以根据某些条件改变自身结构。java利用反射机制获得类似动态语言的特性。

  • Reflection（反射）机制允许程序在执行期间借助Reflection API 获得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

  • 加载完类之后，堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了完整的类结构信息，通过这个对象看到类的结构，类似镜子，称之为：反射。

  • 反射优点:实现动态创建对象和编译，灵活性大。缺点：影响性能，使用反射是一种解释操作，是在告诉JVM希望它完成什么，慢于直接执行相同操作。

//反射机制演示
public class ReflectionDemo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的Class对象
        Class c1 = Class.forName("com.jayz.annotationDemo.User");
        System.out.println(c1);

        Class c2 = Class.forName("com.jayz.annotationDemo.User");
        Class c3 = Class.forName("com.jayz.annotationDemo.User");
        //一个类在内存中只有一个Class对象，一个类被加载后，类的整个结构都会封装在Class对象中
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());//二者结果相等，指向同一对象

    }
}

//实体类
class User{
    private String name;
    private int id;
    private int age;

    public User() {
    }

    public User(String name, int id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }
}

Class类：一个Class对象宝华了特定某个结构的有关信息

  1. Class对象只能由系统建立
  2. 一个加载的类在JVM中只会有一个Class实例，一个Class对象对应的是一个加载到JVM中的.class文件
  3. Class类是Reflection的根源，针对任何想动态加载的类，必须获得Class对象

2.1 获取Class类的实例

  1. 已知具体类，通过类的class属性获取，最安全，性能最高（Class c = Person.class;)
  2. 已知某个类的实例，调用该实例的getClass()方法获取Class对象（Class c = person.getClass()😉
  3. 已知一个类的全类名，且该类在类路径下，通过Class类的静态方法forName() 获取，需要抛出异常
  4. 内置基本数据类型直接使用类名.Type
  5. 利用ClassLoader
  • 数组只要元素类型与维度一样，就是同一个class

2.2 Java 内存

  • 堆：存放new出来的对象和数组；可以被所有线程共享，不存放别的对象引用

  • 栈：存放基本变量类型；存放引用对象的变量（此引用在堆的具体地址）

  • 方法区：可以被所有线程共享；包含所有的class和static变量

类的加载过程：

  1. 类的加载(Load)

    • 将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表该类的java.lang.Class对象
    • 类加载器把类(class)装载进内存。有引导类加载器（Bootstap Classloader)(JVM自带，C++编写，负责Java平台核心库，无法直接获取），扩展类加载器(Extension Classloader)（负责jre/lib/ext目录下的jar包装入工作库），系统类加载器(System Classloader)（负责java -classpath所指的目录下的类与jar包装入，最常用的加载器）
    • 双亲委派机制确保类的正确加载
    //类加载器演示
public class ClassLoaderDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //获取系统类加载器的父类加载器--->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        //获取扩展类加载器的父类加载器-->根加载器
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前类是哪个加载器加载的
        ClassLoader classLoader = Class.forName("com.jayz.annotationDemo.ClassLoaderDemo").getClassLoader();
        System.out.println(classLoader);

        //测试JDK内置类加载
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);

        //获取系统类加载器加载的路径
        System.out.println(System.getProperty("java.class.path"));
    }
}

  2. 类的链接(Link)

    • 将Java类的二进制代码合并到JVM运行环境中
      • 验证：确保加载的类信息符合JVM规范，没有安全问题
      • 准备：正式为类变量(static)分配内存并设置类变量默认初始值，内存都将在方法区中分配。
      • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程

  3. 类的初始化(Initialize)

    • 执行类构造器()方法的过程。类构造器方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生（不是类对象的构造器）

    • 初始化一个类时，若发现其父类还没有初始化，先触发其父类的初始化

    • 虚拟机保证一个类的()方法在多线程环境中被正确加锁和同步。

    • 发生类的初始化（类的主动应用），被动引用不会。

      1. 主动引用：当虚拟机启动时，先初始化main方法所在的类
      • new 一个类的对象
      • 调用类的静态方法和静态成员
      • 使用java.lang.reflect包中的方法对类进行反射调用
      • 初始化一个类，若其父类没有被初始化，先初始化父类
      1. 被动引用
        • 访问一个静态域时，只有真正声明这个域的类才会被初始化（如子类引用父类的静态变量，不会导致子类初始化）
        • 通过数组定义类引用，不会触发此类的初始化
        • 引用常量不会触发初始化（常量在链接阶段存入常量池）
public class InitiDemo {
    static {
        System.out.println("Main所在类加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
        //Son son = new Son(); //Main所在类加载 父类被加载 子类被加载

        // 反射
        //Class.forName("com.jayz.annotationDemo.Son");//Main所在类加载 父类被加载 子类被加载

        //被动引用
        //System.out.println(Son.b);//Main所在类加载 父类被加载 2
        Son[] sons = new Son[5]; //Main所在类加载
    }
}

class Father{
    static int b = 2;

    static{
        System.out.println("父类被加载");
    }
}

class Son extends Father{
    static {
        System.out.println("子类被加载");
        m = 300;
    }

    static int m = 100;
    static final int M = 1;

}

2.3 类信息

示例：获取类相关信息（方法，属性，构造器，父类，接口，注解）

//获取类的信息
public class ClassInformation {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.jayz.annotationDemo.User");

        //获得类的名字
        System.out.println(c1.getName()); //获得包名+类名
        System.out.println(c1.getSimpleName()); //获得类名

        //获得类的属性
        Field[] fields = c1.getFields(); //只能找到 public 属性
        fields = c1.getDeclaredFields(); //
        for(Field field:fields) {
            System.out.println(field);
        }

        //获得指定属性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        //获得类的方法
        Method[] methods = c1.getMethods(); //获得本类及父类的所有public方法
        for(Method method:methods) {
            System.out.println(method);
        }
        methods = c1.getDeclaredMethods(); //获得本类的所有方法
        for(Method method:methods) {
            System.out.println(method);
        }

        //获得构造器方法
        Constructor constructor = c1.getConstructor();
        Constructor[] constructors = c1.getConstructors();
    }
}

示例：**通过反射构造对象，调用方法和属性（私有的，setAccessible(true))。**使用反射会影响程序效率。

//反射操作
public class ReflectionDemo02 {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得Class对象
        Class c1 = Class.forName("com.jayz.annotationDemo.User");

        //构造对象
        User u1 = (User)c1.newInstance();  //调用类的无参构造器，若定义了有参构造，没有定义无参构造，无法使用此方法
        System.out.println(u1);

        //通过构造器创建对象
        Constructor constructor = c1.getConstructor(String.class, int.class, int.class);
        User u2 = (User)constructor.newInstance("jay", 01, 18);
        System.out.println(u2);

        //通过反射调用普通方法
        User u3 = (User)c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);

        //invoke 激活方法
        setName.invoke(u3,"jay2");
        System.out.println(u3.getName());

        //反射操作属性
        User u4 = (User)c1.newInstance();
        Field name = c1.getDeclaredField("name");//访问私有属性，权限不够
        //关闭权限
        name.setAccessible(true);
        name.set(u4,"jay3");
        System.out.println(u4.getName());
    }
}

2.4 ORM （Object relation Mapping):利用注解和反射完成类和表结构的映射关系

public class ORM_Demo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.jayz.annotationDemo.Student01");

        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //获得注解的 value的值
        TableJay tableJay = (TableJay)c1.getAnnotation(TableJay.class);
        String value = tableJay.value();
        System.out.println(value);

        //获得类指定的注解
        Field name = c1.getDeclaredField("name");
        FieldJay fieldJay = name.getAnnotation(FieldJay.class);
        System.out.println(fieldJay.columnName());
        System.out.println(fieldJay.length());
        System.out.println(fieldJay.type());
    }
}

@TableJay("db_student")
class Student01{
    @FieldJay(columnName = "db_id",type = "int",length = 10)
    private int id;
    @FieldJay(columnName = "db_name",type = "varchar",length = 3)
    private String name;
    @FieldJay(columnName = "db_age",type = "int",length = 10)
    private int age;

    public Student01(){}

    public Student01(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableJay{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldJay{
    String columnName();
    String type();
    int length();
}
zxh1996
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
反射注解基本操作
m0_49025634的博客
04-03 679
文章目录注解和反射1.注解-annotation1.1 元注解1.2 通过基本反射读取注解2.反射-Java Reflection2.1 java反射机制功能2.2 反射优缺点2.3 创建类的三种方式2.4 获取类名、属性、方法、构造器2.5 动态创建对象执行方法2.5.1 创建对象的方法2.5.2 通过反射调用某个方法、属性等2.6 反射操作泛型2.6.1 获取泛型的参数类型2.6.2 获取泛型返回值的的类型 注解和反射 1.注解-annotation 1.1 元注解 元注解的作用就是负责注解其他注解（
注解与反射 -（反射篇）
jianyong的博客
03-20 513
注解、反射、自定义注解、API、Class对象
java注解和通过反射获取注解值
weixin_44613100的博客
06-22 3345
注解学习
Java 中的反射（包含注解类简介）
wzskqfzl_zg的博客
02-16 390
value 和 isdelete 都有默认值，所以可赋值可不赋值，在类上的注解中，这两个参数我都未赋值，在属性上的注解中，我给 value 赋值为“清华”，与默认值“hello world”不一致，可以理解为这次使用中赋值覆盖了默认值，最终 Student 的注解中 value 的输出结果为“hello world”，info 的注解中 value 的输出结果为“清华”一个 Class 对象包含了特定某个类的有关信息：类的数据成员名、方法和构造器，类实现的接口等。1. @Target：注解的作用目标。
注解及反射的使用
T_Antry
09-09 8572
上一章我讲了连接池，本来是说要讲注解的，讲注解的话要讲好多铺垫才行，算了试着说一说了。 注解的使用前言一、注解是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这边讲的话，可能不会把它所有的应用都讲，因为说一个的话，其它的原理都是相同的。 提示：好的，下面正式开始 一、注解是什么？ 当然了，这个意义还是要讲。毕竟我一开始对这个注解也很陌生，注解？一想想到注释了 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。Java 语言中的类、方法、变量、参数和包等
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1146
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
java基础之注解和反射
08-05
java基础之注解和反射
一种基于Java注解和反射机制的Excel文件读写操作方法.pdf
06-27
一种基于Java注解和反射机制的Excel文件读写操作方法.pdf
java学习：05.Java注解和反射.md
01-22
Java是一种高级的面向对象的程序设计语言，它具有广泛的应用和强大的跨平台特性。Java语言于1995年由Sun公司推出，由Java之父詹姆斯高斯林设计。Java的设计目标是提供一种易学易用、功能强大的编程语言，使开发人员...
java注解和反射的12个demo.zip
04-28
关于反射和注解的的源码，包含12个demo案例，学自b站狂神。希望可以帮助到小狂神们，同时也给自己的笔记收藏纪念一下
注解以及如何利用反射获取注解
qq_42500503的博客
10-07 7654
什么是注解 1.Annotation是从JDK5.0开始引入的新技术 2.Annotation的作用 : （1）不是程序本身，可以对程序作出解释(这一点和注释(comment)没什么区别) （2）可以被其他程序(比如:编译器等)读取 3.Annotation的格式： 注解是以"@注释名"在代码中存在的,还可以添加一-些参数值,例如:@SuppressWarnings(value="unchecked") 4.Annotation在哪里使用? 可以附加在package , class , method ,
jdk8新特性----Lambda表达式
w_t_y_y的博客
05-11 440
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
jar包增量更新分析
junlaiyan的专栏
05-16 136
借助jdeps分析出jar包的增量文件
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 520
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 202
java导出excel动态加载多sheet多复杂表头
Android Model引入其他aar包 导致无法打包成aar
最新发布
qq_27400335的博客
05-16 236
Android Model引入其他aar包 导致无法打包成aar
java中实现缓存的几种方式
shenxiaomo1688的博客
05-16 511
Redis 是C语言开发的一个开源高性能键值对的内存数据库，可以用来做数据库、缓存、消息中间件等场景，是一种NoSQL(not-only sql,非关系型数据库)的数据库。下面我们介绍在springboot项目中的使用springboot中有redis的starter我们直接引用即可然后在spring配置文件中加入如下设置，这里用的是properties形式的文件，host是部署redis的服务器ip，port是端口号，password是密码，如果没有设置密码不填即可同样我们编写接口测试。
java注解反射导包
05-30
在使用Java注解和反射时，需要导入以下两个包： ```java import java.lang.annotation.Annotation; import java.lang.reflect.Field; ``` 其中，`java.lang.annotation.Annotation`包含所有注解的通用接口，`java....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值