java注解和反射

最新推荐文章于 2025-11-30 18:24:05 发布

原创最新推荐文章于 2025-11-30 18:24:05 发布 · 125 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #jvm #开发语言

本文详细介绍了Java中的注解（Annotation）和反射（Reflection）机制。注解提供了一种安全的方式来元数据标记代码，包括内置注解、元注解和自定义注解的创建与使用。反射则允许程序在运行时检查和操作类、对象、方法等，包括类加载、类初始化的条件以及反射API的使用。通过反射，可以动态创建对象、调用方法和访问属性，同时也探讨了反射对性能的影响。

文章目录

一.注解Annotation
二.反射reflection

一.注解Annotation

1.简介

“从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。”

2.基本注解(内置注解)

//表示一个方法声明打算重写父类方法
@Override
//修饰方法、属性、类,表示不鼓励程序员使用,通常是因为它很危险或者有更好的选择
@Deprecated
//抑制编译器警告,需添加一个参数,参数为需抑制的警告类型
@SuppressWarnings
//抑制堆污染警告
@SafeVarargs
//保证这个接口只有一个抽象方法，注意这个只能修饰接口
@FunctionalInterface

3.元注解

简介:元注解是用来修饰注解的注解，通常用于注解的定义。
类型:

@Retention:注解生命周期

生命周期:SOURCE<CLASS<RUNTIME

@Target:注解作用范围

作用范围:

取值	注解使用范围
METHOD	可用于方法上
TYPE	可用于类或者接口上
ANNOTATION_TYPE	可用于注解类型上（被@interface修饰的类型）
CONSTRUCTOR	可用于构造方法上
FIELD	可用于域上
LOCAL_VARIABLE	可用于局部变量上
PACKAGE	用于记录java文件的package信息
PARAMETER	可用于参数上

@Documented:说明注解被包含在javadoc中
@Inherited:说明子类可以继承父类中的该注解

4.自定义注解

定义注解

//2.添加元注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
//1.创建一个注解类
public @interface MyAnnotation01 {
//3.添加成员变量(当只有一个成员变量时,最好变量名使用value)
  String name() default "";//default "":默认值为""
  int age() default 0;
}

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

使用自定义注解

//注解参数应包含所有注解成员变量,不写则为默认值
@MyAnnotation01(name = "fisher",age = 18)
class Test01{}
//若成员变量名为value,则不用写value=
@MyAnnotation02("fisher")
class Test02{}

二.反射reflection

1.概述

简介:

Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。

功能

1.在运行时判断任意一个对象所属的类
2.在运行时构造任意一个类的对象
3.在运行时判断任意一个类所具有的成员变量和方法
4.在运行时获取泛型信息
5.在运行时调用任意一个对象的成员变量和方法
6.在运行时处理注解
7.生成动态代理

对比正常方法:

正常方法:引入需要的包类名称—>通过new实例化对象----取得实例化对象

反射方法:实例化对象—>getClass方法—>得到完整的包名称

优缺点:

优点:动态创建对象和编译,具有很强的灵活性

缺点:影响性能

主要API:

java.lang.Class:代表一个类

java.lang.reflect.Method:代表类的方法

java.lang.reflect.Field:代表类的成员变量

java.lang.reflect.Constructor:代表类的构造器

2.Class类的概述及获取

拥有Class对象的类型:

class:外部类,成员(成员内部类,静态内部类),局部内部类,匿名内部类
interface:接口
[]:数组
enum:枚举
annotation:注解
primitive type:基本数据类型
void
Class

五种获取Class类的方法:

//方法1.由已知具体类名.class方法获取,安全可靠,性能高
Class c1 = User.class;
//方法2.已知类的实例,调用实例的getClass方法获取Class对象
User user = new User();
Class c2 = user.getClass();
//方法3.已知类的全类名,通过Class类的静态方法forName()获取.
Class c3 = Class.forName("com.fisher.Reflect.User");
//方法4.通过type方法(仅适用于基本内置类型)
Class c4= Integer.TYPE;
//获得父类类型
Class c5 = c1.getSuperclass();

3.类的加载与ClassLoader

3.1java内存分析:

堆:

存放new的对象和数组

可以被所有线程共享,不会存放别的对象引用

栈:

存放基本数据类型及其具体数值

引用对象的变量及该引用在堆里面的具体地址

方法区:

特殊的堆

可以被所有线程共享

包含了所有的class和static变量

3.2类的加载

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

加载:

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构,然后生成一个代表这个类的java.lang.Class对象.（获取，不能主动创建）

链接: 将Java类的二进制代码合并到JVM的运行状态之中的过程。
1. 验证: 确保加载的类信息符合JVM规范，没有安全方面的问题
2. 准备: 正式为类变量(static)分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
3. 解析: 虚拟机常量池内的符号引用（常量名）替换为直接引用(地址)的过程。
初始化:
1. 执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的，不是构造该类对象的构造器)。
2. 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
3. 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

3.3什么时候发生类初始化

类的主动引用(一定会发生类的初始化)

1.当虚拟机启动，先初始化main方法所在的类
2.new一个类的对象
3.调用类的静态成员(除了final常量)和静态方法
4.使用java.lang.reflect包的方法对类进行反射调用
5.当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

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

1.当访问一个静态域时，只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量，不会导致子类初始化
2.通过数组定义类引用，不会触发此类的初始化
3.引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了)

代码演示:

public class Test01 {
    static {
        System.out.println("main 类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //会产生类的引用方法
        //1.new一个对象,若其父类没初始化,则先初始化其父类
        Son son = new Son();
        //2.调用类的静态成员
        Son.m;
        //3.反射
        Class.forName("cn.bloghut.reflection.Son");
        
        //不会产生类的引用方法
        //1.子类调用父类静态变量
        System.out.println(Son.b);
        //2.数组类引用
        Son[] sons =new Son[5]; 
        //3.引用常量
        System.out.println(Son.M);
    }
}

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;
}

3.4类加载器

类加载器的作用:

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

类缓冲:

标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象

类加载器:

引导类加载器:
用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取。

扩展类加载器:
负责jre/lib/ext目录下的jar包或-java.ext.dirs指定目录下的jar包装入工作库。

系统类加载器:
负责java -classpath或-Djava.class.path所指的目录下的类与jar包装入工作，是最常用的加载器。

双亲委派机制:

通过双亲委派机制，可以避免类的重复加载，当父加载器已经加载过某一个类时，子加载器就不会再重新加载这个类。

测试代码:

public static void main(String[] args) throws ClassNotFoundException {
        //获取系统的类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //获取系统类加载器的父类加载器->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);//sun.misc.Launcher$ExtClassLoader@1540e19d

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

        //测试当前类是哪个加载器加载的
        ClassLoader c1 = Class.forName("cn.bloghut.reflection.Test07").getClassLoader();
        System.out.println(c1);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //测试JDK内部哪个加载器加载的
        ClassLoader c2 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(c2);//null
    }

4.操作运行时类的对象

4.1获取运行时类的完整结构

可获得的结构:

1.实现的全部接口Interface

2.所继承的父类Superclass

3.全部的构造器Constructor

4.全部的方法Method

5.全部的Field

6.注解Annotation

具体代码:

User类:

package com.fisher.Reflect;

/**
 * @author 大润发第一渔夫
 * @data 2022-07-15 13:08
 */
public class User{
    private String name;
    public int age;

    public User() {
    }


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

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

}

测试类:

package com.fisher.Reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * @author 大润发第一渔夫
 * @data 2022-07-15 16:35
 */
public class ReflectionTest02 {
    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException, ClassNotFoundException {
        Class c1 = Class.forName("com.fisher.Reflect.User");
        //获得类的名称
        System.out.println(c1.getName());//获得包名+类名
        System.out.println(c1.getSimpleName());//类名
        //获得类的属性
        Field[] fields = c1.getFields();//只能找到public 修饰的属性
        for (Field field : fields) {
            System.out.println(field);
        }
        fields = c1.getDeclaredFields();//找到全部的属性
        for (Field field : fields) {
            System.out.println(field);
        }
        //获取指定属性的值
        //Field name = c1.getField("name");报错
        Field name = c1.getDeclaredField("name");
        System.out.println(name);
        //获得类的方法
        Method[] methods = c1.getMethods();//获取本类及父类的全部public 方法
        for (Method method : methods) {
            System.out.println("getMethods（）："+method);
        }
        methods = c1.getDeclaredMethods();//获取本类的所有方法
        for (Method method : methods) {
            System.out.println("getDeclaredMethods（）："+method);
        }
        //获取指定方法
        Method getName = c1.getMethod("getName",null);
        System.out.println(getName);
        Method setName = c1.getDeclaredMethod("setName",String.class);
        System.out.println(setName);
        //获取指定的构造器
        Constructor[] constructors = c1.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("getConstructors"+constructor);
        }
        constructors = c1.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("getDeclaredConstructors（）："+constructor);
        }
        //获取指定构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class);
        System.out.println("指定"+declaredConstructor);
    }
}

4.2动态操作对象

/****************通过反射创建对象*******************************************/
Class c1 =Class.forName("com.fisher.Reflect.User");
//简便方法:通过调用无参构造器(需有无参构造器)
User user1 = (User) c1.newInstance();
//普通方法:通过构造器构造对象
//1.使用getConstructor获取构造器
Constructor constructor=c1.getConstructor(String.class,int.class);
//2.使用newInstance()构造对象
User user2 = (User) constructor.newInstance("渔夫", 18);

/****************通过反射调用方法*******************************************/
//1.使用getDeclaredMethod获取方法
Method setName = c1.getDeclaredMethod("setName", String.class);
Method getName = c1.getDeclaredMethod("getName");
//2.使用invoke(调用对象,方法参数)调用方法:
setName.invoke(user2,"fisher");

/****************通过反射操作属性*******************************************/
//1.使用getField获取属性
Field name = c1.getField("name");
Field age = c1.getField("age");
//2.使用setAccessible(true)设置属性为可访问(默认为false)
name.setAccessible(true);
//3.使用set(调用对象,属性参数)修改属性
name.set(user2,"hujing");
age.set(user2,100);

Object invoke(Object obj,Object … args)

1.Objectb对应原方法的返回值，若原方法无返回值，此时返回null
2.若原方法若为静态方法，此时形参Object obj可为null
3.若原方法形参列表为空，则Object[] args为null
4.若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。

setAccessible(true)

1.Method和Field、Constructor对象都有setAccessible()方法
2.setAccessible作用是启动和禁用访问安全检查的开关。
3.参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。
1.提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。
2.使得原本无法访问的私有成员也可以访问
4.参数值为false则指示反射的对象应该实施Java语言访问检查

性能对比:

package com.fisher.Reflect;

import java.lang.reflect.Method;

/**
 * @author 大润发第一渔夫
 * @data 2022-07-15 18:32
 */
    public class ReflectionTest04 {
        public static void main(String[] args) throws Exception {
            test01();
            test02();
            test03();
        }

        //普通方式调用
        public static void test01() {
            User user = new User();
            long startTime = System.currentTimeMillis();

            for (int i = 0; i < 100000000; i++) {
                user.getName();
            }

            long end = System.currentTimeMillis();
            System.out.println("普通方式调用10亿次：" + (end - startTime) + "ms");
        }

        //反射方式调用
        public static void test02() throws Exception {
            Class c1 = Class.forName("com.fisher.Reflect.User");
            User user = (User) c1.newInstance();

            Method getName = c1.getDeclaredMethod("getName", null);

            long startTime = System.currentTimeMillis();

            for (int i = 0; i < 100000000; i++) {
                getName.invoke(user, null);
            }

            long end = System.currentTimeMillis();
            System.out.println("反射方式调用10亿次：" + (end - startTime) + "ms");
        }

        //反射调用，关闭进程
        public static void test03() throws Exception {
            Class<?> c1 = Class.forName("com.fisher.Reflect.User");
            User user = (User) c1.newInstance();

            Method getName = c1.getDeclaredMethod("getName", null);
            getName.setAccessible(true);
            long startTime = System.currentTimeMillis();

            for (int i = 0; i < 100000000; i++) {
                getName.invoke(user, null);
            }

            long end = System.currentTimeMillis();
            System.out.println("关闭检测方式调用10亿次：" + (end - startTime) + "ms");
        }
    }
/*
结果:
普通方式调用10亿次：2ms
反射方式调用10亿次：129ms
关闭检测方式调用10亿次：107ms
 */

5.操作注解

ORM:Object relationship Mapping -->对象关系映射

在这里插入图片描述

1.类和表结构对应
2.属性和字段对应
3.对象和记录对应

代码演示:

package com.fisher.Reflect;

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

/**
 * @author 大润发第一渔夫
 * @data 2022-07-15 19:11
 */
public class ReflectionTest05 {
    public static void main(String[] args) throws Exception{
        Class c1 = Class.forName("com.fisher.Reflect.Student");
        //1.获取注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //2.获取类注解的值
        AnnotationType annotationType = (AnnotationType) c1.getDeclaredAnnotation(AnnotationType.class);
        String value = annotationType.value();
        System.out.println(value);
        //3.获取类中属性的注解的值
        //1)获得类的属性
        Field name = c1.getDeclaredField("name");
        //2)获得此属性的AnnotationField注解
        AnnotationField annotation = name.getAnnotation(AnnotationField.class);
        //3)打印指定值
        System.out.println(annotation.name());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}
@AnnotationType("student")
class Student{
    @AnnotationField(name = "name",type = "varchar",length = 3)
    private String name;
    @AnnotationField(name = "age",type = "int",length = 10)
    private int age;
    @AnnotationField(name = "id",type = "int",length = 10)
    private int id;

    public Student() {
    }

    public Student(String name, int age, int id) {
        this.name = name;
        this.age = age;
        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;
    }

    public int getId() {
        return id;
    }

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

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

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface AnnotationField {
    String name();
    String type();
    int length();
}