Java基础——注解与反射

最新推荐文章于 2024-07-20 23:59:39 发布
最新推荐文章于 2024-07-20 23:59:39 发布
阅读量195 收藏 1
点赞数
分类专栏： Java全栈 文章标签： java 反射 jvm spring 注解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38684427/article/details/112602370
版权

1. 简介

最近在学习框架技术时频繁地遇到注解与反射相关的原理，之前学习的javaSE中虽然学过，但是记忆模糊，因此打算重新复习一下这方面的知识。

2. 注解

2.1 概念

Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。Java 语言中的类、方法、变量、参数和包等都可以被标注。
注解与注释有相似的，他们都是对其标注的代码的一种说明。但是，注解更加复杂：

  • 有明确的编写语法：注解的声明需要符合java的命名规范，且自定义注解需要满足Java的语法；
  • 有明确的使用位置：注解的使用位置是需要指明的；
  • 有明确的有效期：一个注解的生命周期包括：源代码，class文件，和运行时。
  • 具有强制性：注解所规定的内容用户在使用时必须遵守，否则编译无法通过。

java中是使用反射的机制来读取注解的。

2.2 核心机制

1. 元注解 meta-annotation

java中提供了四个元注解，即注解的注解，我们在编写自己的注解时，需要关注这四个注解，并按照需求对这四个注解进行赋值。

  • @Document：说明该注解将写入javadoc中；
  • @Retention：说明该注解可以被保存到什么时候（SOURCE<CLASS<RUNTIME）;
  • @Target: 描述该注解的使用范围（METHOD，CLASS，FIELD）；
  • @Inherited：说明子类可以继承父类中的该注解。

我们来看一下Target注解的内容：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    /**
     * Returns an array of the kinds of elements an annotation type
     * can be applied to.
     * @return an array of the kinds of elements an annotation type
     * can be applied to
     */
    ElementType[] value();
}

ElementType是一个枚举类型，其可枚举的值包括：

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Formal parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE,

    /**
     * Module declaration.
     *
     * @since 9
     */
    MODULE
}

2. 自定义注解

java中使用@interface来创建自己的注解，此时会自动帮我们继承java.lang.annotation.Annotation接口。格式为：

@元注解
@interface MyAnnotation {
}

我们可以在注解中定义参数，其格式为参数类型 参数名();且只能定义String、基本数据类型,数组和enum。注意：注解中参数的赋值是没有顺序的。如果该注解只有一个值，那么说明时可以使用value=xxx的方式赋值。

@Target(value = ElementType.TYPE)
@interface MyAnnotation1 {
//    注解的参数,如果使用了注解并且没有为参数设置初始值，那么就会报错
    String name();
//    如果该参数的值默认是空，那么不需要初始化
    String addr() default "";
}
@MyAnnotation1(name="yindarui")
@Target(value = ElementType.METHOD)
@interface MyAnnotation2 {
}

使用value作为注解的参数名时，当只有一个参数，在赋值时可忽略字符串。

@MyAnnotation3
public class AnnotationTest {
//    在使用时可以忽略
    @MyAnnotation2("zhangsan")
    @MyAnnotation3
    public static void main(String[] args) {

    }
}
@Target(value = ElementType.TYPE)
@interface MyAnnotation1 {
//    注解的参数,如果使用了注解并且没有为参数设置初始值，那么就会报错
    String name();
//    如果该参数的值默认是空，那么不需要初始化
    String addr() default "";
    int id() default 0; // 0表示默认为0
    int sal() default -1; // -1表示报不存在
    String[] client() default {"zhangsan", "lisi"};
}
@MyAnnotation1(name="yindarui")
@Target(value = ElementType.METHOD)
@interface MyAnnotation2 {
//    使用value作为参数名
    String value();
}

//Target注解的value是一个数组，所以可以指定多个作用域
@Target(value={ElementType.TYPE, ElementType.METHOD})
@interface MyAnnotation3 {

}

3. 反射

3.1 概念

反射机制使得java具备了动态性，即在java程序运行的时候，程序可以根据运行时的代码，改变自身的一些结构。
反射机制允许java程序在运行时，借助一些API来获取一个类的全部信息，并直接对该类中的属性、方法进行操作。

3.2 核心机制

我们知道，java的代码在编写完成，通过编译器编译之后会生成.class文件，这称为字节码文件。一个字节码文件会通过类加载器加载到Java虚拟机中，在被调用时进行实例化。
**反射机制想创建对象也必须获取到该对象的字节码文件。**在java中，class文件也是一个类。通常通过Class c = Class.forName("java.lang.String");，或者Object.getClass()获得。

类加载机制

首先我们先了解一下class文件。
先通过反射的方式获取到class文件：如下的三个HashCode值是相同的，说明class文件在JVM运行时只会保存一份。一个类在被加载到内存中，其所有的内容都会被封装到Class对象。

Class person1 = Class.forName("com.yindarui.annotation.Person");
Person person = new Person();
Class person2 = person.getClass();
System.out.println(person1.hashCode());
System.out.println(person2.hashCode());
//结果是一样的
1967205423
1967205423

那么到底什么是Class类呢？所有的其他类都由Class类创建，但是Class类本身也是一个类。其封装了一个对象（编写的代码）里面的全部内容。JVM可以通过Class对象创建别的对象。同样的，对于任何一个对象，JVM都可以通过对象的全限定名找到其Class文件，并获取该Class文件的全部内容。

3.3 使用Class类

Class类用方法：

类型方法功能
staticforName(String name)返回指定类名的对象
publicObject newInstance()通过class对象调用默认的构造函数返回一个对象
publicString getName()返回该class对象的全限定名
publicClass getSuperClass()返回该class对象的父类的class对象
publicClass[] getInterfaces()返回该class对象实现的全部接口
publicClassLoader getClassLoader()返回该class对象的类加载器
publicConstructor[] getConstructors()返回该class对象实现的全部接口
publicMethod getMethod(String name, Class<?>… parameterTypes))返回该class对象指定的方法对象
publicMethod[] getMethods())返回该class对象的全部方法对象
publicField getDeclaredFields()返回Field的一个数组

如果你熟悉java类包含的内容，那么你一定会很好理解Class类中提供的方法。这几乎包括了一个类中所有的信息。（还可以获取Annotation，这就是框架中大量使用的）

1. 获取Class文件

ArrayList<Class> classes = new ArrayList<>();
classes.add(Object.class); //根类
classes.add(Iterable.class); // 接口
classes.add(Override.class); // 注解
classes.add(ElementType.class); // 枚举类
classes.add(String[].class); // 数组
classes.add(String[][].class); // 数组
classes.add(int.class); // 基本数据类型
classes.add(void.class); // 空类型
classes.add(Class.class); // Class本身也是一个
for (int i = 0; i < 9; i++) {
    System.out.println(classes.get(i).hashCode());
}
// 结果：对于数组而言，一维数组和二维数组即使类型相同，其对应的Class文件也不同。
1426407511
589431969
1967205423
42121758
20671747
257895351
874088044
783286238
705927765

2. java 的内存模型

在这里插入图片描述类的加载过程是：

  1. load：将class文件读入内存，并创建一个Java.lang.Class对象。class文件是静态的代码，需要将这些代码转化成运行时的一些数据结构，比如为一些值设计数据结构。
  2. link：将类的二进制数据处理并放入JRE；
    1. 验证：检查代码，确保没有错误；
    2. 准备：为类变量分配内存空间并设置默认的初始值；
    3. 解析：虚拟机中的常量池的符号引用替换直接引用。
  3. initialize：JVM对类进行初始化。首先会执行<clint>()方法，即类构造器，完成对类的初始化。初始化类的时候，必须先初始化其父类。

我们来看一下这个过程：静态代码块会在类被加载时就执行，我们在获取一个类的Class对象时就会把这个Class文件加载进来。
要明确：加载只是把文件读入，并进行分配一定的内存空间，而初始化一个类则会消耗大量的资源，使用反射的方式加载类属于被动加载，很多时候不会触发多余的类的初始化：图片来自b站狂神视频
在这里插入图片描述

3. 类加载器

在JVM的内存模型中，类加载器就是负责找到这个类的class文件并加载到JVM中。存储class文件的地方叫方法区，这个区中保存这加载过的class文件，并提供一定的缓存机制，以减少频繁的从磁盘中加载类文件。
java提供了几种类加载器：图片来自b站狂神视频
在这里插入图片描述所谓的不同的类加载器，其实就是负责加载不同地方的class文件。

ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);
ClassLoader parent = systemClassLoader.getParent();
System.out.println(parent); // AppClassLoader
ClassLoader parent1 = parent.getParent(); // PlatformClassLoader
System.out.println(parent1); // null
System.out.println(Object.class.getClassLoader()); // null
双亲委派机制

JVM在加载类的时候是从启动加载器向下找的，即如果我们自定义一个java.lang.String类型，是无法被加载进JVM的。因为JVM通过boostrap ClassLoader 获取时就发现了这个类，加载后就停止寻找了。
这样做保证了Java代码的执行的正确性与安全性。

4. 通过反射创建对象

使用newInstance方法创建对象需要该类有无参构造器。
此外，我们还可以用别的方法创建：

  1. Class类的getDeclaredConstructor() 获取构造器；
  2. 向构造器中传递参数的class文件，包括该构造器的所有参数；
  3. 通过Constructor进行实例化。
package com.yindarui.annotation;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 *
 */
public class Constructor {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c1 = Class.forName("com.yindarui.annotation.Student");
        java.lang.reflect.Constructor stuCon = c1.getDeclaredConstructor(int.class, String.class);
        Object yindarui = stuCon.newInstance(1, "yindarui");
        System.out.println(yindarui.toString());
        Method setId = c1.getDeclaredMethod("setId", int.class);
        System.out.println("通过invoke来修改id参数");
        setId.invoke(yindarui,20);
        System.out.println(yindarui.toString());
        System.out.println("通过invoke来修改name参数, 此时setName方法是私有的");
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.setAccessible(true);
        setName.invoke(yindarui,"helloworld");
        System.out.println(yindarui.toString());
    }
}

class Student {
    private int id;
    private String name;

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

    public void setId(int id) {
        this.id = id;
    }
    private void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

结果：
在这里插入图片描述

总之，通过反射来操作属性和方法时，一定要传递你要操作的对象。注意：如果你访问的属性、方法或者构造器是私有的，那么在调用之前一定要使用setAccessible来获取权限。

5. 反射获取注解

注解开发的核心就是利用反射机制获取一个class文件中的注解内容。通常有几种方式：

  • 通过class获取全部注解；
  • 通过指定某个注解名称获取注解；
  • 通过某个属性或者方法获取标记在其上的注解；
package com.yindarui.annotation;
import java.lang.annotation.*;
import java.lang.reflect.AnnotatedType;
import java.lang.reflect.Field;


@MyAnnotation5("hello")
public class ReflectionForAnnotation {
    @MyAnnotation4("id = 10")
    public int id;
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class aClass = Class.forName("com.yindarui.annotation.ReflectionForAnnotation");
        Field id = aClass.getDeclaredField("id");
//        获取全部的注解
        Annotation[] annotation2 = aClass.getAnnotations();
//        获取指定的注解
        MyAnnotation5 annotation1 = (MyAnnotation5) aClass.getAnnotation(MyAnnotation5.class);
        System.out.println(annotation1);
        System.out.println(annotation1.value());
//       通过属性名获取标记在属性上的注解,方法也一样
        MyAnnotation4 annotation = id.getAnnotation(com.yindarui.annotation.MyAnnotation4.class);
//       获取在id属性上的全部注解
        Annotation[] annotations = id.getAnnotations();
        System.out.println(annotation.value());
    }
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface MyAnnotation4{
    String value();
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface MyAnnotation5{
    String value();
}

结果：
在这里插入图片描述

yindarui
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
注解和反射（之一：什么是注解和反射）
qq_54343969的博客
04-26 249
注解和反射（之一：什么是注解和反射） 一、注解 注解入门 Annotation是从JDK5.0开始引入的新技术． Annotation的作用: 不是程序本身，可以对程序作出解释.(这一点和注释(comment)没什么区别) 可以被其他程序(比如:编译器等)读取. Annotation的格式: 注解是以"@注释名"在代码中存在的，还可以添加一些参数值﹐例如:@SuppressWarnings(value=“unchecked”). Annotation在哪里使用? 可以附加在package ,
通过反射来操作注解
niceYF的博客
03-24 474
先创建几个注解 //类名的注解 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @interface Tableyf{ String value(); } //属性的注解 @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) @interface fieldyf{ String columnName(); String type();
java注解与反射
你佳哥
12-11 179
基于：【狂神说Java】注解和反射 目录1 注解1.1 内置注解1.2 元注解 1 注解 注解是java5开始引入的新基础，注解不是程序本身，但是注解可以被其他程序读取，注释不能。 形式上@注解名(value)，可以在里面加入参数值； 可以附加在package、class、method、field上面，相当于额外添加辅助信息，可以通过反射机制实现对元素的访问； 1.1 内置注解 @Override：定义在java.lang.Override中，此注释只能修饰方法，表示一个方法声明打算重写父类的方法声明
Java注解与反射详解
it浅阳的博客
11-21 266
注解 概述 Java注解（Annotation）又称Java标注，是JDK1.5引入的一种注释机制。Java中的类、构造器、方法、属性、参数都可以用注解进行标注。例如junit的@Test注解，重写方法的@Override注解等。 作用 对Java中类、构造器、方法、属性、参数做标记，用来特殊处理。根据业务需求来决定。例如junit的@Test注解，就用来标记这个方法是测试方法，没有标注就不能当成测试方法执行。重写方法的@Override注解，用来标注该方法是重写父类（父接口）方法，如果不是就会报错等。 自
注解和反射的理解
qq_45790350的博客
06-30 317
反射 Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。==> 本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。 Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。 通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。 在运行时期，一个类只有一个Class
java注解、java反射机制 jdbc 封装
12-30
总之，这个案例结合了Java的三大利器——注解、反射和JDBC，旨在创建一个高效、灵活且易于扩展的数据访问层。对于想要深入理解Java高级特性的开发者来说，这是一个极好的学习资源。通过实践和研究，你可以掌握如何...
Java使用自定义注解实现函数测试功能示例
08-25
Java 使用自定义注解实现函数测试功能示例主要介绍了 Java 使用自定义注解实现函数测试功能，结合实例形式分析了 Java 自定义注解在函数测试过程中的相关功能、原理与使用技巧。 一、 自定义注解 在 Java 中，...
Java自定义注解的详解
08-29
在这个教程中，我们将学习 Java 的注解，如何定制注解，注解的使用以及如何通过反射解析注解。 Java 自定义注解的详解 ------------------------ ### 创建自定义注解 创建自定义注解和创建一个接口相似，但是注解...
java面试——深圳-OPPO-Java高级.zip
09-26
5. **反射与注解**： - 反射机制：动态获取类信息，创建对象，调用方法，修改属性，以及反射在设计模式中的应用。 - 注解：元数据的使用，自定义注解，以及使用反射读取注解信息。 6. **设计模式**： - 常见设计...
黑马程序员入学Java知识——精华总结.doc
05-09
以上只是Java知识体系的一部分，深入学习Java还需要掌握更多的概念和技术，如反射、注解、泛型、Lambda表达式、并发编程、Spring框架等。通过不断学习和实践，你可以成为一位出色的Java开发者。
java如何查看包中的类_java – 如何获取包中的所有类名？
weixin_28936857的博客
02-26 618
这是我开发的一个定制解决方案来查找包的所有类：public class ClassFinder {private static final char PKG_SEPARATOR = '.';private static final char DIR_SEPARATOR = '/';private static final String CLASS_FILE_SUFFIX = ".class";pr...
写Java 代码
11-03 229
一、编写Java源程序 二、编译Java源代码 三、执行Java源文件 四、JVM如何执行字节码文件 对于任何一门语言，要想达到精通的水平，研究它的执行原理(或者叫底层机制)不失为一种良好的方式。 在本篇文章中，将重点研究java源代码的执行原理，即从程序员编写JAVA源代码，到最终形成产品，在整个过程中，都经历了什么？每一步又是怎么执行的？执行原理又是什么？ （一）装载字节码文件 当 .java...
Java注解与反射原理说明
weixin_44782075的博客
03-20 941
一 点睛 注解若想发挥更大作用，还需借助反射机制之力。通过反射，可以取得一个方法上声明的注解的全部内容。 一般有两种需求： 1 取得方法中全部的注解，通过调用getAnnotations来实现。 2 判断操作是否是指定注解，通过调用getAnnotation来实现。 下面从源码角度来说明怎样获取这些注解信息。 二 源码导读——取得方法中全部的注解 public class AccessibleOb...
Java 反射之AnnotatedElement
来啊 快活啊
02-21 4377
11
Java 基础知识之 Java 反射
大鹏的博客
08-05 282
Java 反射机制是 Java 自诞生以来就具备的能力，用于在 Java 程序运行过程中动态的获取类的信息，调用类中的方法。
Java 反射包下常用类介绍（Member、Field、AnnotatedElement、Type、Method 等等）
qq_42419406的博客
06-03 1299
sdf
在eclipse中导入本地的jar包配置Junit环境步骤（包含Junit中的方法一直标红的解决方法）
最新发布
weixin_70987470的博客
07-20 210
从本地导入Junit
Java内存模型
weixin_44267758的博客
07-19 544
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 466
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java注解与反射深度解析
本文将深入探讨Java编程中的两个重要概念——注解（Annotation）和反射（Reflection）。这些特性自JDK 5.0版本起被引入，极大地丰富了Java语言的功能，并在实际开发中有着广泛的应用。 12.1 注解 注解是一种元编程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值