Java注解和反射

最新推荐文章于 2022-08-16 14:13:06 发布

LitPoor

最新推荐文章于 2022-08-16 14:13:06 发布

阅读量1w

点赞数 2

文章标签： java

本文链接：https://blog.csdn.net/qq_50806424/article/details/119730020

版权

Java注解和反射

一、反射（Reflection）

在学习反射前我们先了解一下动态语言和静态语言

动态语言和静态语言

动态语言

在运行中可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他代码结构上的改变，主要的动态语言有JavaScript、Python、PHP、C#

静态语言

与动态语言相对的，在运行程序过程中代码结构不发生改变的语言叫做静态语言，如C、C++、Java。Java不是动态语言，但Java有一定的动态性，这种动态性我们可以用反射机制来实现，Java的动态性让我们编程的时候更加灵活！

什么是反射

Java 反射，就是在运行状态中

获取任意类的名称、package信息、所有属性、方法、注解、类型、类加载器等
获取任意对象的属性，并且能改变对象的属性
调用任意对象的方法
判断任意一个对象所属的类
实例化任意一个类的对象
实现动态代理

简而言之，反射机制可以让我们获得任何类的内部信息（包括私有类型），Java 的动态就体现在这。通过反射我们可以实现动态装配，降低代码的耦合度；动态代理等，体现出很大的灵活性。但反射对性能会产生影响，使用反射机制基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求，这类操作总是慢于直接执行相同的操作，反射的过度使用会严重消耗系统资源！

class类

JDK 中 java.lang.Class 类，就是为了实现反射提供的核心类之一，一个 jvm 中一种 Class 只会被实例化一次
class是由JVM在执行过程中动态加载的。JVM在第一次读取到一种class类型时，将其加载进内存。如果该class类型中方法含有其他类，也只有在执行该方法时用到其中包含的那个类才会将其加载进内存。
每加载一种class，JVM就为其创建一个Class类的实例，并关联起来.
基本数据类型，数组，void，class（内部类，外部类），enum，注解，interface都可以有class对象

以String类为例，当JVM加载String类时，它首先读取String.class文件到内存，然后，为String类创建一个Class实例并关联起来：

Class cls = new Class(String);

这个Class实例是JVM内部创建的，如果我们查看JDK源码，可以发现Class类的构造方法是private，只有JVM能创建Class实例，我们自己的Java程序是无法创建Class实例的。

所以，JVM持有的每个Class实例都指向一个数据类型（class或interface)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pxx6JPxF-1629086174428)(C:\Users\微瞬\AppData\Roaming\Typora\typora-user-images\image-20210815234904759.png)]

一个Class实例包含了该class的所有完整信息：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wmfwbjzz-1629086174429)(C:\Users\微瞬\AppData\Roaming\Typora\typora-user-images\image-20210815235145852.png)]

这种通过Class实例获取class信息的方法称为反射

获取class对象的三种方法

方法一：直接通过一个class的静态变量class获取：

Class cls = String.class;

方法二：如果我们有一个实例变量，可以通过该实例变量提供的getClass()方法获取：

String s = "Hello";
Class cls = s.getClass();

方法三：如果知道一个class的完整类名，可以通过静态方法Class.forName()获取：

Class cls = Class.forName("java.lang.String");

一个简单的实例：

public class Test {
    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 = void.class; //void
        Class c8 = Class.class; //Class
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
    }
}

运行结果：

class java.lang.Object
interface java.lang.Comparable
class [Ljava.lang.String;
class [[I
interface java.lang.Override
class java.lang.annotation.ElementType
void
class java.lang.Class

动态代理

动态代理是JDK提供的动态创建接口对象的方式，它可以让我们不编写实现类，直接通过JDK提供的一个Proxy.newProxyInstance()创建了一个接口对象

一个简单示例：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


public class Main {
    public static void main(String[] args) {
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method);
                if (method.getName().equals("morning")) {
                    System.out.println("Good morning, " + args[0]);
                }
                return null;
            }
        };
        Hello hello = (Hello) Proxy.newProxyInstance(
            Hello.class.getClassLoader(), // 传入ClassLoader
            new Class[] { Hello.class }, // 传入要实现的接口
            handler); // 传入处理调用方法的InvocationHandler
        hello.morning("Bob");
    }
}

interface Hello {
    void morning(String name);
}

在运行期动态创建一个interface实例的方法如下：

定义一个InvocationHandler实例，它负责实现接口的方法调用；
通过`Proxy.newProxyInstance()创建interface

实例，它需要3个参数：
1. 使用的ClassLoader，通常就是接口类的ClassLoader；
2. 需要实现的接口数组，至少需要传入一个接口进去；
3. 用来处理接口方法调用的InvocationHandler实例。
将返回的Object强制转型为接口。

其实就是JVM帮我们自动编写了一个上述类（不需要源码，可以直接生成字节码）。

二、注解（Annotation）

什么是注解

注解是Java语言用于工具处理的标注：
注解可以配置参数，没有指定配置的参数使用默认值；
如果参数名称是value，且只有一个参数，那么可以省略参数名称。
注解可以被编译器打包进class文件
注解可以附加在package，class，method，field上面，相当于给他们添加了额外的辅助信息，我们可以通过反射实现对这些元数据的访问。

内置注解

作用在代码的注解

@Override - 检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
@Deprecated - 标记过时方法。如果使用该方法，会报编译警告，通常是因为它很危险或者存在更好的选择，在调用该注解表示的方法时，idea会用一条杠将该方法划去。
@SuppressWarnings - 指示编译器去忽略注解中声明的警告，SuppressWarnings(“all”)抑制所有警告。

作用在注解上面的注解（元注解）

@Retention - 标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问（source<class<runtime）。

@Documented - 标记这些注解是否包含在用户文档中。
@Target - 用于描述注解的使用范围。
@Inherited - 标记这个注解是继承于哪个注解类(默认注解并没有继承于任何子类)

自定义注解

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

格式：

public @interface 注解名 { 注解内容 }

public class Test {

    @MyAnnotation(name = "hello", schools = "s", id = {1, 2})
    public void test() {
    }

    //参数名为value时，若只写一个参数，参数名可以省略
    @MyAnnotation2("hello")
    public void test2() {
    }

}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    //注解的参数 ： 参数类型 + 参数名() ;
    //default设置默认值
    String name();

    int age() default -1;

    String[] schools();

    int[] id();
}

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


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

LitPoor

关注

2
点赞
踩
0

收藏

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

Java注解和反射一、反射（Reflection）在学习反射前我们先了解一下动态语言和静态语言动态语言和静态语言动态语言在运行中可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他代码结构上的改变，主要的动态语言有JavaScript、Python、PHP、C#静态语言与动态语言相对的，在运行程序过程中代码结构不发生改变的语言叫做静态语言，如C、C++、Java。Java不是动态语言，但Java有一定的动态性，这种动态性我们可以用反
复制链接

扫一扫