java之注解与反射

最新推荐文章于 2024-05-22 23:24:01 发布
最新推荐文章于 2024-05-22 23:24:01 发布
阅读量122 收藏 2
点赞数 1
分类专栏： java后端开发 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53784206/article/details/111675239
版权

一、注解

1、元注解

负责注解其他注解，Java定义了四个标准的meta-annotation

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

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

    • SOURCE < CLASS < RUNTIME(默认)

  • @Document：表示是否将注解生成在JAVAdoc中

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

2、自定义注解

public @interface MyTiger {
    String[] value();
}
  • @interface来声明一个注解
  • 其中value()其实是声明了一个配置参数，而不是方法，value就是参数的名称
  • 返回值类型就说参数的类型（返回值只能是基本类型Class，String，enum）
  • 可以用default来声明参数的默认值
  • 如果只有一个参数成员，一般参数名为value
  • 注解元素必须要有值，我们定义注解元素时，常用空字符串，0为默认值

总结：注解可以附加在package，class，method，field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问

二、反射

1、静态vs动态语言

  • 动态语言：运行时可以改变其结构的语言 灵活

    • C#，JS，PHP，Python
    function f() {
    var x = "var a = 1; var b = 3; alert(a+b)";
    eval(x);
}

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

    • Java、C、C++

2、概述

  • 正常方式：
    在这里插入图片描述

  • 反射方式：
    在这里插入图片描述

3、Class类

（1）概述

  • Class本身也是类
  • Class对象只能由系统建立对象
  • 一个加载的类在JVM中只会有一个Class实例
  • 一个Class对象对应的是一个加载到JVM中的一个.class文件
  • 每个类的实例都会记得自己是由哪个Class实例所生成
  • 通过Class可以完整地得到一个类中的所有被加载的结构
  • Class类是Reflection的根源，针对任何你想加载、运行的类，唯有先获得的相应的Class对象
    在这里插入图片描述

（2）获取Class类的不同方式

package com.atlige.reflection;

import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * @author Jeremy Li
 * @data 2020/12/24 - 11:04
 */
public class test1 {
    public static void main(String[] args) throws Exception {
        Person person = new Student();
//        System.out.println("这个人是：" + person.name);

        // 方式一: 通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());

        // 方式二: forName获得
        Class c2 = Class.forName("com.atlige.reflection.Student");
        System.out.println(c2.hashCode());

        // 方式三: 通过类名.class获得
        Class c3 = Student.class;
        System.out.println(c3.hashCode());

        // 方式四: 基本内置类型的包装类都有一个Type属性
        Class c4 = Integer.TYPE;
        System.out.println(c4);

        System.out.println(c1.getSuperclass());
        Student s1 = (Student) c1.newInstance();
        Method[] declaredMethods = c1.getDeclaredMethods();

    }
}

class Person{

    String name;

    public String getName() {
        return name;
    }

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

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

    public Person() {
    }

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

class Student extends Person{

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

class Teacher extends Person{

    public Teacher() {
        this.name = "老师";
    }
}

（3）所有类型的Class对象

package com.atlige.reflection;

import java.lang.annotation.ElementType;

public class test2 {
    public static void main(String[] args) {
        Class c1 = Object.class; // 类
        Class c2 = Comparable.class; // 接口
        Class c3 = String[].class; // 一维数组
        Class c4 = int[][].class; // 二维数组
        Class c5 = Override.class; // 注解
        Class c6 = ElementType.class; // 枚举
        Class c7 = Integer.class; // 基本数据类型
        Class c8 = void.class; // void
        Class c9 = Class.class; // Class

        System.out.println(c1);  // class java.lang.Object
        System.out.println(c2);  // interface java.lang.Comparable
        System.out.println(c3);  // class [Ljava.lang.String;
        System.out.println(c4);  // class [[I
        System.out.println(c5);  // interface java.lang.Override
        System.out.println(c6);  // class java.lang.annotation.ElementType
        System.out.println(c7);  // class java.lang.Integer
        System.out.println(c8);  // void
        System.out.println(c9);  // class java.lang.Class
        
        // 只要元素类型和维度一样，就说同一个class
        int[] int1 = new int[10];
        int[] int2 = new int[1000];
        System.out.println(int1.getClass().hashCode());     // 460141958
        System.out.println(int2.getClass().hashCode());     // 460141958

    }
}

4、Java内存分析

在这里插入图片描述

package com.atlige;

public class test1 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
    }

}

class A{
    static {
        System.out.println("A类的静态代码块初始化");
        m = 300;
    }

    static int m = 100;

    public A(){
        System.out.println("A类的无参构造器初始化");
    }
}

（1）类的加载

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

内存图分析：

package com.atlige;
/*
    1.加载到内存，会产生一个类对应的class对象
    2.链接，链接结束后 m=0
    3.初始化
        <clinit>(){
            System.out.println("A类的静态代码块初始化");
            m = 300;
            m = 100;
        }
        
        m=100
 */
public class test1 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
    }

}

class A{
    static {
        System.out.println("A类的静态代码块初始化");
        m = 300;
    }

    static int m = 100;

    public A(){
        System.out.println("A类的无参构造器初始化");
    }
}

注意点：

  • 在test类加载的时候，在堆空间中就产生了Class对象

（2）类的初始化

  • 在类的主动引用时一定会发送类的初始化
    • 当虚拟机启动时，先会初始化main方法所在的类
    • new一个类的对象
    • 通过反射创建对象
    • 调用类中的静态成员（除final常量）和静态方法
    • 初始化一个类，如果其父类没有初始化，则会先初始化父类
  • 在类的被动引用时不会发送类的初始化

（3）类加载器

  • 作用：将class字节码文件加载到内存中，并将静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口
  • 类缓存：标准的JavaSE类加载器可以按要求查找类，一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间，不过JVM垃圾回收机制可以回收这些Class对象

在这里插入图片描述

  • 分类
    • 引导类加载器：c++编写，加载Java平台核心库，无法直接获取
    • 扩展类加载器：负责jre/lib/ext目录下的jar包或java.ext.dirs指定目录下的jar包装入工作库
    • 系统类加载器：java-classpath或java.class.path所指的目录下的类，最常用的加载器

在这里插入图片描述

双亲委派机制：

  • 当某个.class文件需要加载时，各级Classloader会自下而上依次检测是否是否已经加载过此类，直到BootstapClassloader，已经不存在父类加载器时，若此类未加载过，再考虑是否自身加载器是否可以加载，若无法加载，则自上而下依次检测是否可以加载，一直到最底层，如果没有任何加载器能加载，就会抛出ClassNotFoundException

如图所示：
在这里插入图片描述

（4）获取运行时类的完整结构

package com.atlige;

import javax.sound.midi.Soundbank;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Date;

public class test2 {
    public static void main(String[] args) throws Exception {
        Class c1 = Class.forName("com.atlige.User");

        ClassLoader classLoader = c1.getClassLoader();
        System.out.println(classLoader);
        System.out.println("============================");
        // getFields()获得public的属性
        Field[] fields = c1.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("=========================");
        // 获得所有属性
        fields = c1.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        Field name = c1.getField("name");
        System.out.println(name);

        Method[] methods = c1.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("=========================");
        methods = c1.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        Method getName = c1.getDeclaredMethod("getName");
        System.out.println(getName);
        Method setName = c1.getDeclaredMethod("setName", String.class);
        System.out.println(setName);
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, Date.class);
        System.out.println(declaredConstructor);
    }
}

package com.atlige;

import javax.sound.midi.Soundbank;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Date;

public class test3 {
    public static void main(String[] args) throws Exception {
        Class c1 = Class.forName("com.atlige.User");
        // 默认调用无参构造器
        User user1 = (User) c1.newInstance();
        System.out.println(user1);
        // 调用有参构造器
        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, Date.class);
        User user2 = (User) constructor.newInstance("小李", 18, new Date());
        System.out.println(user2);

        // 通过反射调用普通方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(user1, "李哥");
        System.out.println(user1);

        // 通过反射调用属性
        Field name = c1.getDeclaredField("name");
        name.set(user1, "李哥set后");
        System.out.println(user1);
        System.out.println("================");
        Field age = c1.getDeclaredField("age");
        // 不能直接操作私有属性，需要关闭程序的安全检测，属性或方法或构造器的 setAccessible(true);
        age.setAccessible(true);
        age.set(user1, 21);
        System.out.println(user1);

    }
}

总结

  • 调用invoke方法时
    • 返回值为原方法的返回值，无返回值为null
    • 若原方法为静态方法，此时形参Object为null
    • 原方法参数列表为空，在Object[] args为null
    • 调用private方法时，先调用方法的setAccessible(true)
关于开启setAccessible的性能测试 
package com.atlige;

import java.lang.reflect.Method;

public class test4 {
    
    public static void t1(){
        User user = new User();
        long startTime = System.currentTimeMillis();

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

        long endTime = System.currentTimeMillis();

        System.out.println("普通方式执行10亿次：" + (endTime - startTime) + "ms");
    }

    public static void t2() throws Exception {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName");

        long startTime = System.currentTimeMillis();

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

        long endTime = System.currentTimeMillis();

        System.out.println("反射方式执行10亿次：" + (endTime - startTime) + "ms");
    }

    public static void t3() throws Exception {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName");
        getName.setAccessible(true);
        long startTime = System.currentTimeMillis();

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

        long endTime = System.currentTimeMillis();

        System.out.println("反射方式且关闭安全检测执行10亿次：" + (endTime - startTime) + "ms");
    }

    public static void main(String[] args) throws Exception{
        t1();  // 3ms
        t2();  // 1416ms
        t3();  // 1034ms
    }
}

5、反射操作泛型

package com.atlige;

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 test5 {

    public void t1(Map<String, User> map, List<User> list){

    }

    public Map<String, User> t2(){
        System.out.println("t2");
        return null;
    }

    public static void main(String[] args) throws Exception {
        Method method = test5.class.getDeclaredMethod("t1", 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 = test5.class.getDeclaredMethod("t2");
        Type genericReturnType = method.getGenericReturnType();
        System.out.println("#" + genericReturnType);
            if ( genericReturnType instanceof ParameterizedType){
                Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }

}

6、反射操作注解

package com.atlige;

import java.lang.annotation.*;
import java.util.Date;

public class test6 {
    public static void main(String[] args) throws Exception {
        Annotation[] annotations = User1.class.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        TypeLi typeLi = User1.class.getAnnotation(TypeLi.class);
        System.out.println(typeLi.value());

        FieldLi fieldLi = User1.class.getDeclaredField("name").getAnnotation(FieldLi.class);
        System.out.println(fieldLi.columnName());
        System.out.println(fieldLi.type());
        System.out.println(fieldLi.length());
    }
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldLi {
    String columnName();
    String type();
    int length();
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface TypeLi {
    String value();
}
@TypeLi("db_user")
class User1 {
    @FieldLi(columnName = "username", type = "varchar", length = 10)
    public String name;
    @FieldLi(columnName = "userage", type = "varchar", length = 6)
    private int age;
    @FieldLi(columnName = "userbirthday", type = "datetime", length = 8)
    private Date birthday;

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

    private String sayHi(){
        return "hello, world";
    }

    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 Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public User1(String name, int age, Date birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public User1() {
    }
}

思维导图

在这里插入图片描述

小李同学呦
关注
专栏目录
MySQL float 类型的精度
afternoone的专栏
05-14 3万+
总结：要得到1位或2位精确小数的话，整数不能高于32767即：f因为 2E15=32768 所以最多只能正确处理0~32767的整数，要得到3位精确小数的话，整数不能高于16383即：f
Spring学习一
weixin_42178281的博客
11-23 228
Spring的介绍 Spring是一个企业级的Java应用开发的框架 Spring是一个开源框架，轻量级，基础版本只有2M大小 Spring主要使用开发Java应用程序，该框架的目标是使开发的应用更加容易使用 Spring的优势： 简化Java的开发 基于轻量级和最小侵入式开发 通过依赖注入和面向接口实现松耦合 基于切面进行声明式开发 通过切面和模板减少样式代码 学习要点： Spring的介绍 Spring的IOC介绍（控制反转） Spring的DI介绍(依赖注入) Spring的AOP介绍（横向切面技术）
mysql下float类型使用一些误差详解
09-11
我想很多朋友都不怎么会在mysql中使用float类型，特别是用到金钱时我们可能会用双精度来做，我们知道mysql的float类型是单精度浮点类型不小心就会导致数据误差
java注解和反射
远航丨的博客
09-16 141
java 注解和反射 注解 Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。 Java 语言中的类、方法、变量、参数和包等都可以被标注。和 Javadoc 不同，Java 标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌入到字节码中。Java 虚拟机可以保留标注内容，在运行时可以获取到标注内容 。 当然它也支持自定义 Java 标注。 注解也是一种类的类型，他使用的修饰符为 @interface 例如： public @interface
JAVA-注解和反射
码说芯语的博客
03-16 506
1、什么是注解？ Annotation是从JDK5.0开始引入的新技术 Annotation的作用： 不是程序本身，可以对程序作出解释（这一点和注释（comment）类似） 可以被其他程序（比如：编译器等）读取 Annotation的格式： 注解是以“@注释名”在代码中存在的，还可以添加一些参数值，列如：@SuppressWarnings(value=“unchecked”). Annotation在哪里使用？ 可以附加在package,class,method,field等上面，相当于给他们添加了额外的
Java注解与反射原理说明
08-26
总的来说，Java注解提供了代码的元信息，而反射则是读取和利用这些元信息的手段。两者结合，能够帮助开发者实现更加灵活和动态的程序设计，提高代码的可维护性和可扩展性。理解并熟练掌握注解和反射的使用，对于提升...
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
Java自定义注解使用反射获取字段注解
10-31
总结一下，Java的自定义注解结合反射机制，为我们提供了强大的元数据功能，可以用来增强代码的可读性、可维护性，甚至实现一些动态的功能。在实际开发中，自定义注解常用于框架的实现、AOP切面编程、配置管理等领域...
Java使用注解和反射简化编程的方法示例
08-25
Java使用注解和反射简化编程的方法示例 Java中的注解和反射机制可以简化编程的方式，提高编程效率。下面将通过实例形式，分析Java使用注解和反射简化编程的相关操作技巧。 Java中的注解是一种meta信息，提供了...
Java：注解和反射
希望有点用
05-21 2480
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
Java 注解和反射
最新发布
kezhou的博客
05-22 782
注解是 JDK 5.0 引入的新技术。注解是不是程序本身，但可以对程序做出解释；可以被其他程序（比如编译器）读取。注解是以 “@注解名” 在代码中存在，还可以添加一些参数，例如 @SuppressWarnings(value=“ubchecked”)。可以加在 package、class、method、field 等上面，相当于给他们添加额外的信息；我么可以通过反射机制编程实现对这些元数据的访问。使用@interface自定义注解时，自动继承了接口。@interface用来声明一个注解；
JAVA注解和反射
打伞的木头人
04-18 1111
JAVA的注解 什么是注解 注解目前还是非常流行的，我们常用的Sprinng就是利用注解。 添加注解可以代码简洁，阅读方便 ，使用方便。 首先，先来看一下我们java自带的元注释，在java.lang.annotation包下面，其中@Native@Repeatable 不是元注解（元注解就是注解新建注解的注解） 注释名称 解释 @Target 表示该注解可以用于什么地方，可能...
Java注解和反射
qq_41355222的博客
04-01 90
1.内置注解 - @Override:定义在java.lang.override中，此注解只适用于修饰方法，表示一个方法声明打算重写超类中的另一个方法声明。 - Deprecated: 定义在java.lang.deprecated中，此注解可以用来修饰方法、属性、类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择 - SuppressWarnings:定义在java.lang.suppressWarnings中，用来抑制编译时的警告信息，与前两个注解有所不同，需要添加一个参数才能正确
Java注解与反射详解
"java注解和反射的个人学习笔记" 在Java编程中，注解（Annotation）和反射（Reflection）是两种强大的工具，它们为开发者提供了更高级别的抽象和动态操作能力。注解自JDK 5.0版本起引入，主要用于提供元数据，即...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值