Java注解与反射

最新推荐文章于 2024-05-11 23:45:05 发布

魅Lemon

最新推荐文章于 2024-05-11 23:45:05 发布

阅读量345

点赞数

分类专栏： # Java基础文章标签： java 后端

本文链接：https://blog.csdn.net/lemon_TT/article/details/122197698

版权

Java基础专栏收录该内容

26 篇文章 1 订阅

订阅专栏

一、注解Annotation

1、注解介绍

Annotation 是从JDK5.0开始引入的新技术
Annotation不是程序本身，但可以对程序作出解释(和注释差不多) ，也可以被其他程序(编译器等)读取
Annotation注解是以@注解名在代码中存在的，还可以添加一些参数值 , 例如:@SuppressWarnings(value="unchecked")
Annotation可以附加在package , class , method , ﬁeld 等上面 , 相当于给他们添加了额外的辅助信息，我们可以通过反射机制实现对这些元数据的访问

2、内置注解

@Override定义在 java.lang.Override中，此注释只适用于修辞方法, 表示一个方法声明打算重写超类中的另一个方法声明；

@Deprecated定义在java.lang.Deprecated中，此注释可以用于修辞方法，属性，类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择或者已经过时；

@SuppressWarnings定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息。与前两个注释有所不同，你需要添加一个参数才能正确使用，这些参数都是已经定义好了的，我们选择性的使用就好了。

// 还有很多类型
@SuppressWarnings("all")
@SuppressWarnings("unchecked")
@SuppressWarnings(value={"unchecked","deprecation"})

3、元注解

元注解的作用就是负责注解其他注解， Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明；这四种类型在java.lang.annotation包中可以找到 (@Target , @Retention , @Documented, @Inherited )

@Target

描述注解的使用范围(即被描述的注解可以用在什么地方) ；ElementType类中存在常数ANNOTATION_TYPE，CONSTRUCTOR，FIELD，LOCAL_VARIABLE，METHOD，PACKAGE，PARAMETER，TYPE，和TYPE_PARAMETER

@Retention

需要在什么级别保存该注释信息 , 用于描述注解的生命周期(SOURCE < CLASS < RUNTIME)

RetentionPolicy.SOURCE注释将被编译器丢弃；
RetentionPolicy.CLASS注释将由编译器记录在类文件中，但不需要在运行时由VM保留。这是默认行为；
RetentionPolicy.RUNTIME注释将由编译器记录在类文件中，并且由VM在运行时保留，因此可以反射地读取它们。

@Document

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

@Inherited

说明子类可以继承父类中的该注解

4、自定义注解

使用 @interface自定义注解时, 自动继承了java.lang.annotation.Annotation接口

@interface用来声明一个注解，格式：public @interface 注解名 {定义内容 }
注解的每一个方法实际上是声明了一个配置参数
方法的名称就是参数的名称
返回值类型就是参数的类型 (返回值只能是基本类型Class ，String ，enum)
可以通过default来声明参数的默认值
如果只有一个参数成员 , 一般参数名为value
注解元素必须要有值，我们定义注解元素时，经常使用空字符串0作为默认值

public class annotationTest {

    // 显示定义
    @MyAnnotation(value = "value",name = "shawn",age = 18)
    public void test() {

    }
    // 默认名字一般是value
    @MyAnnotation("shawn")
    public void test1() {

    }

}

//自定义一个注解，其中用到了四个元注解
@Target(value = {ElementType.TYPE,ElementType.METHOD})
@Retention(value = RetentionPolicy.RUNTIME) //一般自定义注解，都选择RUNTIME;
@Documented
@Inherited
@interface MyAnnotation{
    // 参数类型，参数名
    String value() default "";
    String name() default "";
    int age() default 0;
}

二、反射Refection

1、静态 VS 动态语言

动态语言是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。主要动态语言：Object-C、C#、JavaScript、PHP、Python等。

静态语言与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！

2、反射概述

1、概述

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

// 在加载了类之后，在堆内存的方法区中，就产生了一个Class类型的对象（一个类只有一个Class对象）
// 该对象包含了完整的类的结构信息。我们可以通过该对象来看到类的完整的结构
// 这个对象就像是一个镜子一样，透过镜子看到类的结构，因此成为反射
Class c = Class.forName("java.lang.String");

正常方式：引入需要的"包类"名称>通过new实例化>取得实例化对象

反射方式：实例化对象>getClass()对象方法>得到完整的"包类"名称

2、功能与优缺点

反射有以下几点功能(不局限以下几点)：

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

反射优缺点：

优点：可以在运行时获得类的各种内容，进行反编译，对于Java这种先编译再运行的特点，能够让我们很方便的创建灵活的代码，这些代码可以在运行时进行装配，不用在组件之间进行代码之间的链接。
缺点：反射会消耗一定的系统资源，假如不需要动态的创建对象的时候，就不要使用反射；反射调用方法的时候可以忽略权限的检查，因此可能会破坏封装性而导致安全问题

3、反射Class类

1、Class详解

Class类对于每个类而言，JRE都为其保留了一个不变的Class类型的对象。一个Class对象包含了特定某个结构的有关信息

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

2、反射常用API

Class类 代表类的实体，在运行的Java应用程序中表示类和接口

Field类 代表类的成员变量（成员变量也称为类的属性）

Method类 代表类的方法

Constructor类 代表类的构造方法

getField、getMethod和getCostructor方法可以获得指定名字的域、方法和构造器。
getFields、getMethods和getCostructors方法可以获得类提供的public域、方法和构造器数组，其中包括超类的共有成员。
getDeclatedFields、getDeclatedMethods和getDeclaredConstructors方法可以获得类中声明的全部域、方法和构造器，其中包括私有和受保护的成员，但不包括超类的成员。

方法名	功能说明
static ClassforName(String name)	返回指定类名name的Class对象
Object newInstance()	调用缺省构造函数，返回Class对象的一个实例
getName()	返回此Class对象所表示的实体（类，接口，数组类或void）的名称。
Class getSuperClass()	返回当前Class对象的父类的Class对象
Class[] getinterfaces()	获取当前Class对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Constructor[] getConstructors()	返回一个包含某些Constructor对象的数组
Method getMothed(String name,Class… T)	返回一个Method对象，此对象的形参类型为paramType
Field[] getDeclaredFields()	返回Field对象的一个数组

3、获取Class类的多种方式

// 若已知是具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高：
Class clazz1 = Person.class;
// 已知某个类的实例，调用该实例的getClass()方法获取Class对象：
Class clazz2 = Person.getClass();
// 已知一个类的全名，且该类在类路径中，可通过Class类的静态方法forName()获取：
Class clazz3 = Class.forName(…);
// 内置基本数据类型的包装类可以直接用
Class clazz4 = Integer.TYPE;
// 还可以利用ClassLoader加载器

哪些类型可以有Class对象

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

4、Java内存模型

1、Java内存划分

2、类的加载过程

加载

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

**链接：**将Java类的二进制代码合并到JVM的运行状态之中的过程。

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

初始化

执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步

3、分析类初始化

类的主动引用（一定会发生类的初始化）

当虚拟机启动，先初始化main方法所在的类
new一个类的对象
调用类的静态成员（除了ﬁnal常量）和静态方法
使用java.lang.reﬂect包的方法对类进行反射调用
当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

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

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

4、类加载器的作用

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

类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器

5、反射创建

1、获取类加载器

package com.zstu.sso;

public class TestUser {
    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/c++)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);//null
        
        //测试当前类是哪个加载器加载的：系统类加载器
        ClassLoader classLoader = Class.forName("com.zstu.sso.TestUser").getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
        
        //测试JDK内置的类是谁加载的：根加载器
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);//null

        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));//各种jdk/jre/jar包路径
    }
}

2、获取类的运行时结构

通过反射获取运行时类的完整结构：Field,Method,Constructor,Superclass,Interface,Annotation；另外反射获取内部类是需要用$隔开

package com.zstu.sso;

public class TestUser {
    public static void main(String[] args) throws ClassNotFoundException, 
            NoSuchMethodException, NoSuchFieldException, 
            InvocationTargetException, IllegalAccessException, 
            InstantiationException {
        Class user = Class.forName("com.zstu.sso.User");
        //获得类的名字
        System.out.println(user.getName());
        System.out.println(user.getSimpleName());
        System.out.println("==============================");
        //获得类的属性
        //user.getFields()只能找到类的public属性
        Field[] fields = user.getDeclaredFields(); //找到全部属性
        for(Field field:fields) {
            System.out.println(field);
        }
        //获得类的指定属性
        Field field = user.getDeclaredField("name");
        System.out.println(field);
        System.out.println("==============================");
        //获得类的方法
        Method[] methods = user.getMethods(); //获得本类以及父类的所有public方法
        for(Method method:methods){
            System.out.println("所有的方法："+method);
        }
        methods = user.getDeclaredMethods(); //获得本类的所有方法(包含私有方法)
        for(Method method:methods){
            System.out.println("本类的方法："+method);
        }
        //获取指定方法
        Method test = user.getDeclaredMethod("test",null);
        Method test1 = user.getDeclaredMethod("test1", String.class);
        System.out.println(test);
        System.out.println(test1);
        System.out.println("==============================");
        //获取类的构造器
        Constructor[] constructors = user.getConstructors(); //获得public的构造器
        for (Constructor constructor : constructors) {
            System.out.println("public构造器："+constructor);
        }
        constructors = user.getDeclaredConstructors(); //获得所有构造器
        for (Constructor constructor : constructors) {
            System.out.println("所有的构造器："+constructor);
        }
        //获得指定的构造器
        Constructor constructor = user.getDeclaredConstructor(String.class, String.class);
        System.out.println(constructor);

        // 调用某个实例化类的方法，会抛出InvocationTargetException, IllegalAccessException,InstantiationException
        test.invoke(user.newInstance());
        test1.invoke(user.newInstance(),"hello");

    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class User {
    private String name;
    private String password;

    public void test(){
        System.out.println("我执行了test的方法啦");
    }

    public void test1(String test1){
        System.out.println("我执行了test1的方法啦，内容是" + test1);
    }
}

3、动态创建对象执行方法

可以通过Class对象创建该类的对象，然后执行该类的方法
如何利用反射机制动态创建对象：

调用Class对象的**newInstance()**方法，要求类必须有一个无参数的构造器，而且类的构造器的访问权限足够；
当类没有无参的构造器的时候，只要在操作的过程中明确指定类中的构造器即可创建对象，步骤如下：首先，通过Class对象获取本类的指定形参类型的构造器；第二步，向构造器的形参中传递一个对象数组进去，里面包含了构造器所需的各个参数；第三步，通过Constructor实例化对象；

通过**Object invoke(Object obj,Object[] args)**调用指定的方法：

Object对应原方法的返回值，若原方法无返回值，此时返回null；
若原方法为静态方法，则obj参数可以为null；
若原方法形参列表为空，则args参数可以为null；
（★）若原方法声明为private，则在调用invoke方法之前，需要先调用**setAccessible(true)**方法，即可访问private的方法；另外反射执行的速度比普通方式要慢很多，如果非得要用反射，而且是多次用的情况下，可以通过关闭检测来提高速度

4、setAccessible

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

三、反射实战

java8在线参考文档：https://docs.oracle.com/javase/8/docs/api/

1、获取泛型信息

对于泛型，Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换的问题，但是，一旦编译成功，所有和泛型有关的类型全部擦除；但是泛型的信息，还是会在加载的过程中存储在Class中

package com.zstu.sso;

public class TestUser {
    public static void main(String[] args) throws NoSuchMethodException {
        //通过反射获取方法参数泛型
        //第一步：获取指定的方法
        Method method = User.class.getDeclaredMethod("test", 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 = User.class.getDeclaredMethod("test1",null);
        Type genericReturnType = method.getGenericReturnType();//通过方法获得返回值泛型

        if(genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }

    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class User {
    private String name;
    private String password;

    public List<String> test1(){
        System.out.println("我执行了test的方法啦");
        return null;
    }

    public void test(Map<String, String> map,List<String> list){
        System.out.println("我执行了test1的方法啦，内容是" + map + list);
    }
}

2、获取注解信息

在类上、字段和方法上的注解都可以通过反射进行读取，不过要注意抛出的异常

package com.zstu.sso;

public class annotationTest {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException,
            InstantiationException, IllegalAccessException, InvocationTargetException {
        Class c1 = Class.forName("com.zstu.sso.MyAnnotationClass");

        //通过反射获取类的注解
        Annotation[] classAnnotations = c1.getAnnotations();
        for (Annotation annotation : classAnnotations) {
            System.out.println(annotation); //@com.zstu.sso.MyAnnotation(name=, value=这是类, age=0)
        }

        //获得指定注解的value值
        MyAnnotation classAnnotation = (MyAnnotation)c1.getAnnotation(MyAnnotation.class);
        String value = classAnnotation.value();
        System.out.println(value); //这是类


        //获得类内部字段的指定注解
        Field field = c1.getDeclaredField("name");
        MyAnnotation fieldAnnotation = field.getAnnotation(MyAnnotation.class);
        System.out.println(fieldAnnotation.value());//field
        System.out.println(fieldAnnotation.age());//18
        System.out.println(fieldAnnotation.name());//这是字段

        //获得类内部方法的指定注解
        Method method = c1.getDeclaredMethod("test");
        MyAnnotation methodAnnotation = method.getAnnotation(MyAnnotation.class);
        System.out.println(methodAnnotation.value());//method
        System.out.println(methodAnnotation.age());//18
        System.out.println(methodAnnotation.name());//这是方法

        // 禁用访问安全检查的开关
        method.setAccessible(true);
        method.invoke(c1.newInstance());// 运行了test方法

    }

}

// 默认名字一般是value
@MyAnnotation("这是类")
@Data
class MyAnnotationClass {

    @MyAnnotation(value = "field",name = "这是字段",age = 18)
    private String name;
    private String password;
    // 显示定义
    @MyAnnotation(value = "method",name = "这是方法",age = 18)
    public void test() {
        System.out.println("运行了test方法");
    }


}

//自定义一个注解，其中用到了四个元注解
@Target(value = {ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(value = RetentionPolicy.RUNTIME) //一般自定义注解，都选择RUNTIME;
@Documented
@Inherited
@interface MyAnnotation{
    // 参数类型，参数名
    String value() default "";
    String name() default "";
    int age() default 0;

}

参考资料

https://www.bilibili.com/video/BV1p4411P7V3

魅Lemon

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java注解与反射

文章目录一、注解Annotation1、注解介绍2、内置注解3、元注解4、自定义注解二、反射Refection1、静态 VS 动态语言2、反射概述1、概述2、功能与优缺点3、反射Class类1、Class详解2、反射常用API3、**获取Class类的多种方式**4、Java内存模型1、Java内存划分2、类的加载过程3、分析类初始化4、类加载器的作用5、反射创建1、获取类加载器2、获取类的运行时结构3、动态创建对象执行方法4、setAccessible三、反射实战1、获取泛型信息2、获取注解信息一、注解
复制链接

扫一扫