反射和注解

最新推荐文章于 2023-02-16 09:35:56 发布
最新推荐文章于 2023-02-16 09:35:56 发布
阅读量98 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiaweilovemingming/article/details/124831987
版权

title: 反射和注解
date: 2022-05-17 22:22:50
categories:

  • 个人博客
  • Java基础
    tags:
  • Java

注解

什么是注解？

定义：注解是放在 Java 源码的类、方法、字段、参数前的一种特殊注释。但是注释会被编译器直接忽略，而注解可以被编译器打包进入 class 文件。

作用：（1）对程序做出解释 （2）对作用域中内容进行检查和约束

格式： @ + “注解名” ，注解也可以有参数，如 @SuppressWarnings(value = “unchecked”)

内置注解

@Override：用于修饰方法，表示这个方法打算重写父类中的同名方法。

@Deprecated：可用于修饰方法，属性，类，表示所修饰内容已经被废弃，不鼓励程序员使用该内容。

@SuppressWarnings：用来抑制编译时的警告信息，必须添加一个参数才能正确使用，如

@SuppressWarnings(value = "all") // 全部抑制
@SuppressWarnings(value = "unchecked")

元注解

定义：负责解释其他注解的注解。

4 个标准元注解

  • @Target：用于描述注解的使用范围，即注解可以被用在什么地方。

  • @Retention：表示需要在什么级别保存该注解信息，用于描述注解的生命周期。

    • SOURCE 源代码级别
    • CLASS 字节码级别
    • RUNTIME 运行时

    RUNTIME > CLASS > SOURCE

  • @Documented 表示是否将我们的注解生成在 JAVAdoc 中。

  • @Inherited 表示子类可以继承父类的注解。

自定义注解

格式：public @interface 注解名{}。

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    String name(); //这里不是成员变量，而是参数 参数名后有括号（）
    int age() default 1;
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    String value(); //只有一个参数成员，默认参数名为 value
}

反射机制

动态语言和静态语言

动态语言：在运行时可以改变其结构的语言，通俗说就是在运行时代码可以根据某些条件改变自身结构

主要的动态语言有：Object-C，C#，JavaScript，Python等

静态语言：运行时结构不变的语言

静态语言有：C，C++，Java

Java 因为反射机制，可以称之为"准动态语言"。使用反射可以让 Java 获得动态语言的特性！

Java Reflection

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

反射的过程与实例化一个对象的过程相反。

实例化一个对象的过程：引入类 -> 通过 new 实例化 -> 获取实例化对象

反射的过程：实例化对象 -> getClass() 方法 -> 获取包含类完整信息的 Class对象

反射的优点和缺点

优点：可以实现动态创建对象和编译，体现出很大的灵活性

缺点：带来一定的性能开销，且存在安全隐患。

Class 对象

通过反射得到的对象是一个 Class 类型的对象。这个对象具有以下特征：

  • Class 本身是一个类
  • Class 对象只能由系统创建
  • 一个加载的类在 JVM 中只有一个 Class 实例
  • 一个 Class 对象对应的是一个加载到 JVM 中的 class 文件
  • 通过 Class 可以获取一个类的所有完整信息

获得反射对象

创建三个对象 Person，Student，Person 是 Student 的父类。

获取反射对象包括以下四种方式：

  • 对象.getClass()
  • Class.forName(“包名”)
  • 类名.class
  • 包装类.TYPE
class Person{
    public  String name;
    public Person(){}
    public Person(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Student extends Person{
    public Student(){
        this.name = "学生";
    }
}

public class Reflect {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println(person.name);
        // 通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());
        // 通过 Class.forname() 获得
        Class c2 = Class.forName("Student");
        System.out.println(c2.hashCode());
        // 方式三 类名.class获得
        Class c3 = Student.class;
        System.out.println(c3.hashCode());
        // 方式 4 通过包装类的 TYPE 获得
        Class<Integer> c4 = Integer.TYPE;
        System.out.println(c4.getTypeName());
        // 获取父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5.getTypeName());
    }
}

类的加载过程

类的初始化

类的主动引用一定会发生类的初始化，具体包括：

  • 虚拟机启动，会先初始化 main 方法所在的类

  • new 一个对象

  • 调用类的静态成员和静态方法 （final常量除外）

  • 对类方法进行反射调用

  • 初始化一个类，如果其父类没有被初始化，就会先初始化其父类

类的被动引用不会发生类的初始化

  • 当访问一个静态域时，只有声明这个域的类会被初始化。例如：子类调用父类的静态变量，子类不会被初始化
  • 通过数组定义类的引用
  • 引用常量
public class Initialize {
    static {
        System.out.println("main 方法所在类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        Son son = new Son(); // new 方法实例化对象 main Father Son 类依次被加载
        Class.forName("Son"); // 反射

        //不会产生类引用的方法
        System.out.println(Son.member); // 依次加载 Main 和 Father 不加载 Son
        Son[] sons = new Son[10]; // 只有 Main 被加载，数组只是给分配了一系列空间
        System.out.println(Son.N); // 只有 Main 被加载，常量在链接阶段就被调入了常量池中
    }
}
class Father{
    static int member = 2;
    static {
        System.out.println("父类被加载");
    }
}

class Son extends  Father{
    static {
        System.out.println("子类被加载");
    }
    static int n = 100;
    static final int N = 10;
}

类加载器

类加载器的作用：将 class 文件字节码内容加载到内存中，将静态数据转换成方法区的运行时数据结构。然后在堆中创建一个 Class 对象，作为方法区中类数据的访问接口。

类加载器有以下三种：

  • 引导类加载器：由 C++ 编写，是 JVM 自带的类加载器，负责加载 Java 核心类库。在 Java 中无法直接获取该加载器。
  • 扩展类加载器：负责加载 jre/lib/ext 目录下 jar 包的加载。
  • 系统加载器：负责 java-classpath 所指目录下的类与 jar 包的加载工作。

获取三个类加载器并打印

public class Loader {
    public static void main(String[] args) throws ClassNotFoundException {
        // 获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        // 获取扩展类加载器
        ClassLoader extensionLoader = systemClassLoader.getParent();
        System.out.println(extensionLoader);
        // 获取引导类加载器
        ClassLoader bootStrapLoader = extensionLoader.getParent();
        System.out.println(bootStrapLoader);

        // 打印当前类的类加载器
        ClassLoader classLoader = Class.forName("Loader").getClassLoader();
        System.out.println(classLoader); // 系统类加载器
        //打印 Object 类的类加载器
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1); // null 引导类加载器，因为无法直接获取 打印 null
    }
}

获取运行时类的完整结构

创建一个 Information 类，通过反射获取 String 类的完整结构。

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Information {
    private static Class aClass;

    public static void main(String[] args) throws NoSuchMethodException {
        Class aClass = String.class;

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

        // 获得类的属性
        Field[] fields = aClass.getFields(); // 获取所有 public 属性
        fields = aClass.getDeclaredFields(); // 获取全部属性
        for (Field field : fields) {
            System.out.println(field);
        }

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

        // 获得构造器
        Constructor[] constructors = aClass.getConstructors(); // public 构造器
        constructors = aClass.getDeclaredConstructors(); // 获取所有的构造器
        Constructor constructor = aClass.getConstructor(String.class);// 获取指定的构造器
        System.out.println(constructor);
    }
}

动态创建对象执行方法

首先创建一个 User 对象

public class User {
    private String name;

    public String getName() {
        return name;
    }

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

    public User() {
        this.name = "Andy";
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }

    public User(String name) {
        this.name = name;
    }
}

创建一个 Dynamic 类，通过反射动态创建 User 类，并调用其方法

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

public class Dynamic {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class<?> aClass = Class.forName("User");
        // 创建一个对象
        User user = (User) aClass.newInstance(); // 调用了 User 的无参构造方法
        System.out.println(user);
        
        // 通过构造器创建对象
        Constructor<?> constructor = aClass.getConstructor(String.class);
        User user1 = (User) constructor.newInstance("mingming");
        System.out.println(user1);
        
        // 通过反射调用方法
        Method setName = aClass.getDeclaredMethod("setName",String.class);
        setName.invoke(user1,"xiaomeng"); // invoke的意思是激活 method.invoke(Object obj,Object[] args)
        System.out.println(user1.getName());
        
        // 通过反射获取属性
        Field name = aClass.getDeclaredField("name");
        name.setAccessible(true);  // 设置可访问性，否则 name.set 会报错
        name.set(user1,"daughter");
        System.out.println(user1.getName());
    }
}

在反射中，调用类中的方法，通过 Method 类来完成，包括以下两步：

  1. 通过 Class 类的 getMethod(String name,Class…parameterTypes) 方法获得一个 Method 对象。
  2. 使用 method.invoke(Object obj,Object[] args) 方法来调用。第一个参数是操作对象，第二个是参数

注意：当需要获取的 Method，Field，Constructor  类为 private 时，需要设置访问可见性

object.setAccessible(true); // object 为 Method、Field 或 Constructor 的实例

setAccessible(true) 指示反射的对象在使用时应该取消 Java 语言的访问检查。

当反射对象频繁被调用时，可以使用此方法，提高执行效率。

反射性能分析

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

// 分析反射的性能
public class Analysis {
    public static void normal() {
        User user = new User();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            user.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方法耗时:" + (endTime - startTime));
    }

    public static void reflect() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Class aClass = Class.forName("User");
        User user = (User) aClass.newInstance();
        Method method = aClass.getMethod("getName", null);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            method.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方法耗时:" + (endTime - startTime));
    }

    public static void access() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Class aClass = Class.forName("User");
        User user = (User) aClass.newInstance();
        Method method = aClass.getMethod("getName", null);
        method.setAccessible(true);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            method.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用setAccessible(true)方法后,反射方法耗时:" + (endTime - startTime));
    }

    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
        normal();
        reflect();
        access();
    }
}

运行代码，得到普通方法耗时 6 ms，反射耗时 1057 ms ，使用 setAssesible(true) 后反射耗时 823 ms。

反射操作泛型

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

// 通过反射获取泛型
public class Template {
    public void test01(Map<String,Integer> map, List<Integer> list){
        System.out.println("test01");
    }
    public Map<String,Integer> test02(){
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method method = Template.class.getMethod("test01", Map.class, List.class);
        Type[] genericParameterTypes = method.getGenericParameterTypes(); // 获取泛型参数信息
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println(genericParameterType);
            if(genericParameterType instanceof ParameterizedType){ //如果传入参数类型
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments(); // 获取实际参数类型
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }
        System.out.println("*********************************************");
        method = Template.class.getMethod("test02", null);
        // 获取泛型返回值信息
        Type genericReturnType = method.getGenericReturnType();
        if(genericReturnType instanceof ParameterizedType){ //如果传入参数类型
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments(); // 获取实际参数类型
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }


    }
}

反射操作注解

反射操作注解的一个经典操作就是 ORM。

用一个实体类对应数据库中的一张表。

在类中，属性中加入注解。通过反射获取注解的值，将注解的值拼接成 SQL 语句，进而操作数据库。

import java.lang.annotation.*;
import java.lang.reflect.Field;

public class operateAnnotation {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> aClass = Class.forName("Book");
        Annotation[] annotations = aClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        MyType annotation = aClass.getAnnotation(MyType.class); // 获取指定类的注解
        System.out.println(annotation.value()); // 获取注解的值

        Field name = aClass.getDeclaredField("name"); // 获取属性
        MyField annotation1 = name.getAnnotation(MyField.class); // 获取属性的 指定注解
        System.out.println(annotation1);
        System.out.println(annotation1.length());
    }
}

@MyType("db_book")
class Book {
    @MyField(name="db_id",type = "int",length = 10)
    private int id;
    @MyField(name="db_name",type = "varchar",length = 10)
    private String name;

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

    public Book() {}

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

// 创建一个类注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface MyType {
    String value();
}

// 创建一个属性注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyField{
    String name();
    String type();
    int length();
}
故、梦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java的反射和注解
weixin_43145539的博客
05-07 874
什么是注解 Java 注解(Annotation)又称 Java 标注，是 JDK5.0 引入的一种注释机制。 Java 语言中的类、方法、变量、参数和包等都可以被标注。和注释不同，Java 标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌入到字节码中。Java 虚拟机可以保留标注内容，在运行 时可以获取到标注内容 。当然它也支持自定义 Java 标注。 注解与注释的区别： 注解是给机器看的注释，而注释是给程序员看的提示，编译时自动忽略注释。 注解的使用场景 编译格式检查 反射中解析 生成
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1161
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
java 反射和注解
weixin_41765786的博客
07-19 1154
示例12】自定义注解}//如果只有一个配置参数，一般命名为value}@MyAnnoation(id=5,name="张三",scoreArr={78,89,34})}}}定义注解的关键字是@interface自定义注解中可以定义多个配置参数，不是成员方法,不是成员变量；说明参数的名称，以及参数值的类型如果只有一个配置参数，一般命名为value如果配置参数是value，并且只有一个配置参数，value可以省略。...
[Java]反射和注解
Summer丶
09-03 228
注解的定义 注解本身没有任何意义，单独的注解就是一种注释，他需要结合其他的反射、插桩等才有意义。 Java注解（Annotation）又称Java标注，是JDK1.5引入的一种注释机制。是元数据的一种形式，提供有关于程序本身的数据。注解对他们注解的代码的操作没有直接影响。 先定义一个注解： @Target(ElementType.TYPE) @Retention(RetentionPolicy.SOURCE) public @interface MyAnnotation { String value
java反射和注解的原理
weixin_42584586的博客
02-16 210
Java反射(Reflection)是指在运行时动态地获取类的信息，包括类的属性、方法、构造器等，并可以使用这些信息来创建对象、调用方法、获取或修改属性值等。Java反射是Java语言的一个特性，它使得我们可以在运行时通过获取类的信息来操作类。 Java注解(Annotation)是在Java程序中的代码中加入的一些元数据，用于对程序代码进行说明、标记和补充。Java注解可以用于对类、方法、参数、...
反射和注解的简单理解
均为学习笔记
03-14 532
1、反射：是Java独有的技术 2、反射是指对于任何一个类，在 “运行的时候” 都可以直接得到这个类的全部成分。 在运行时，可以直接得到这个类的构造器对象。 在运行时，可以直接得到这个类的成员变量对象。 在运行时，可以直接得到这个类的成员方法对象。 反射的核心思想就是得到：编译以后的的class文件对象。 注意：反射是工作在运行时的技术，因为只有运行之后才会有class类对象。 小结：反射的核心思想和关键就是得到：编译以后的class文件对象。 反射是在运行时获取类的字节码文件对象：然后可以
反射与注解（详细）
qq_43377329的博客
03-26 2650
文章目录一、注解Annotation1、什么是注解2、内置注解3、元注解4、自定义注解二、反射机制**1、静态vs动态语言**动态语言静态语言2、java反射机制概述3、java反射机制研究及应用**反射机制提供的功能**优点缺点反射相关主要APIclass类class的常用方法获取class类的实例哪些类型有class对象?4、java内存分析static关键字类的加载过程类的加载和ClassLoader的理解什么时候会发生类的初始化？类加载器的作用双亲委派机制ClassLoader源码分析获取类加载器的
反射与注解
wyy的博客
03-31 865
文章目录一、反射二、注解 一、反射 1.1反射引入 • 编译时知道类或对象的具体信息，此时直接对类和对象进行操作即可，无需反射（reflection） • 如果编译不知道类或对象的具体信息，此时应该如何做呢？使用反射来实现。比如类的名称放在XML文件中，属性和属性值放在XML文件中，需要在运行时读取XML文件，动态获取类的信息 • 反射的应用场合 o 在编译时根本无法知道该对象或类可能属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息 o 比如log4j，Servlet、SSM框架技术都用到了反射
Java反射和注解
ZCC的专栏
09-06 235
一、反射 二、注解 参考链接
java基础之注解和反射
最新发布
08-05
java基础之注解和反射
反射和注解模拟JUnit4单元测试例子
06-19
介绍如何利用反射和注解去简单的模拟JUnit4单元测试的使用，之所以选择JUnit4是因为4.0以后最大的改进就是使用了注解。需要注意的是这里并不是完全的模拟，只是简单实现了一下Runner类和JUnit注解相关的工作流程。...
day021-反射和注解笔记和代码.rar
03-16
第一个next（可以设置生成文档注释的目录），第二个next，设置字符集 如果是UTF-8编码，且有中文，请输入-encoding UTF-8 -charset UTF-8 4. 勾选一个生成完毕后，直接通过浏览器打开的选项 5...
第-章-JAVA反射和注释优秀文档.pptx
11-30
第-章-JAVA反射和注释优秀文档.pptx
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
使用反射和注解模拟Spring的依赖注入
07-27
NULL 博文链接：https://zmx.iteye.com/blog/688299
Java注解与反射原理说明
08-26
今天小编就为大家分享一篇关于Java注解与反射原理说明，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
java反射和注解开发（备java基础，javaee框架原理）
06-09
Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。
反射、注解
12-21
利用反射获取方法对象注解1.概念2.自定义注解3.注解注意事项:4.元注解 反射 一.类加载器 1.类的加载  当我们的程序在运行后，第一次使用某个类的时候，会将此类的class文件读取到内存，并将此类的所有信息存储到一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值