Spring中的注解与反射

目录

前言

注解（Annotation）不是程序，但可以对程序作出解释，也可以被其它程序（如编译器）读取。

注解的格式：以@注释名在代码中存在，还可以添加一些参数值例如@SuppressWarnings(value="unchecked")。

注解可在package、class、method、field等上面使用，作用是为它们添加了额外的辅助信息，从而可以通过反射机制实现对这些元数据的访问。

一、内置（常用）注解

1.1@Overrode

表示某方法旨在覆盖超类中的方法声明，该方法将覆盖或实现在超类中声明的方法。

1.2@RequestMapping

@RequestMapping注解的主要用途是将Web请求与请求处理类中的方法进行映射，注意有以下几个属性：

  • value:映射的请求URL或者其别名
  • value:映射的请求URL或者其别名
  • params:根据HTTP参数的存在、缺省或值对请求进行过滤

1.3@RequestBody

@RequestBody在处理请求方法的参数列表中使用，它可以将请求主体中的参数绑定到一个对象中，请求主体参数是通过HttpMessageConverter传递的，根据请求主体中的参数名与对象的属性名进行匹配并绑定值。此外，还可以通过@Valid注解对请求主体中的参数进行校验。

1.4@GetMapping

@GetMapping注解用于处理HTTP GET请求，并将请求映射到具体的处理方法中。具体来说，@GetMapping是一个组合注解，它相当于是@RequestMapping(method=RequestMethod.GET)的快捷方式。

1.5@PathVariable

@PathVariable注解是将方法中的参数绑定到请求URI中的模板变量上。可以通过@RequestMapping注解来指定URI的模板变量，然后使用@PathVariable注解将方法中的参数绑定到模板变量上。

1.6@RequestParam

@RequestParam注解用于将方法的参数与Web请求的传递的参数进行绑定。使用@RequestParam可以轻松的访问HTTP请求参数的值。

1.7@ComponentScan

@ComponentScan注解用于配置Spring需要扫描的被组件注解注释的类所在的包。可以通过配置其basePackages属性或者value属性来配置需要扫描的包路径。value属性是basePackages的别名。

1.8@Component

@Component注解用于标注一个普通的组件类，它没有明确的业务范围，只是通知Spring被此注解的类需要被纳入到Spring Bean容器中并进行管理。

1.9@Service

@Service注解是@Component的一个延伸（特例），它用于标注业务逻辑类。与@Component注解一样，被此注解标注的类，会自动被Spring所管理。

1.10@Repository

@Repository注解也是@Component注解的延伸，与@Component注解一样，被此注解标注的类会被Spring自动管理起来，@Repository注解用于标注DAO层的数据持久化类。

二、元注解

4个元个元注解分别是：@Target、@Retention、@Documented、@Inherited 。

再次强调下元注解是java API提供，是专门用来定义注解的注解。

  1. @Target

    描述注解能够作用的位置，ElementType取值：

    • ElementType.TYPE，可以作用于类上
    • ElementType.METHOD，可以作用于方法上
    • ElementType.FIELD，可以作用在成员变量上

  2. @Retention

    表示需要在什么级别保存该注释信息（生命周期）：

    • RetentionPolicy.RUNTIME：内存中的字节码，VM将在运行时也保留注解，因此可以通过反射机制读取注解的信息

  3. @Documented

    描述注解是否被抽取到api文档中。

  4. @Inherited

    描述注解是否被子类继承。

三、自定义注解

学习自定义注解对于理解Spring框架十分有好处，即使在实际项目中可能不需要使用自定义注解，但可以帮助我们掌握Spring的一些底层原理，从而提高对整体项目的把握。

/**
 * 自定义注解
 */
public class CustomAnnotation {

    /**
     * 注解中可以为参数赋值，如果没有默认值，那么必须为注解的参数赋值
     * */
    @MyAnnotation(value = "解释")
    public void test(){
    }
}
/**
 */
//自定义注解必须的元注解target，指明注解的作用域（此处指明的是在类和方法上起作用）
@Target({ElementType.TYPE,ElementType.METHOD})
//元注解retention声明该注解在何时起作用（此处指明的是在运行时起作用）
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{

    //注解中需声明参数，格式为：参数类型 + 参数名();
    String value() default "";

}

四、反射机制概述

4.1动态语言与静态语言

4.1.1动态语言

  • 是一种在运行时可以改变其结构的语言，例如新的函数、对象甚至代码可以被引进，已有的函数可以被删除或是进行其它结构上的变化。

  • 主要的动态语言有：Object-C、C#、PHP、Python、JavaScript 等。

  • 以 JavaScript 语言举例：

    /**
 * 由于未指定var的具体类型，函数在运行时间可以改变var的类型
 * */
function f(){
    var x = "var a = 3; var b = 5; alert(a+b)";
    eval(x)
}
4.2.2静态语言
  • 与动态语言相对的、运行时结构不可变的语言就是静态语言，如 Java、C、C++ 等。
  • Java 不是动态语言，但 Java 可以称为”准动态语言“。即 Java 有一定的动态性，可以利用反射机制获得类似于动态语言的特性，从而使得 Java 语言在编程时更加灵活。

4.2Java Reflection（Java 反射）

Reflection（反射）是 Java 被视为准动态语言的关键：反射机制允许程序在执行期间借助 Reflection API 获取任何类的内部信息，并能直接操作任意对象的内部属性及方法。

Class c = Class.forName("java.lang.String")

加载完类后，在堆内存的方法区就产生了一个Class类型的对象（一个类只有一个Class对象），这个类就包含了完整的类的结构信息。我没可以通过这个对象，像镜子一样看到类的结构，这个过程形象地被称之为反射。

通过代码更易于理解：

/**
 * 反射的概念
 */
public class ReflectionTest extends Object{
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的Class对象
        Class c = Class.forName("com.demo.User");
        //一个类在内存中只有唯一个Class对象
        System.out.println(c.hashCode());

    }
}

/**
 * 定义一个实体类entity
 * */
@Data
class User{
    private String userName;
    private Long userId;
    private Date loginTime;
}

由于该类继承 Object，在 Object 类中有 getClass() 方法，该方法被所有子类继承：

@HotSpotIntrinsicCandidate
public final native Class<?> getClass();

注：该方法的返回值类型是一个 Class 类，该类是 Java 反射的源头。

反射的优点：运行期类型的判断、动态加载类、提高代码灵活度。

4.2.1反射机制主要功能
  • 在运行时判断、调用任意一个类的对象信息（成员变量和方法等）；
  • 在运行时获取泛型信息；
  • 在运行时处理注解；
  • 生成动态代理。
4.2.2主要API

  • java.lang.Class：代表一个类

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

  • java.lang.reflect.Method：代表类的方法

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

五、理解Class类并获取Class实例

5.1Class类

前面提到，反射后可以得到某个类的属性、方法和构造器、实现的接口。

  • 对于每个类而言，JRE都为其保留一个不变的 Class 类型的对象；
  • 一个加载的类在 JVM 中只会有一个 Class 实例；
  • Class 类是Reflection的根源，想要通过反射获得任何动态加载的、运行的类，都必须先获取相应的 Class 对象。

5.2获取Class类实例

有以下5种方式可以获取Class类的实例：

  1. 若已知具体的类，可以通过类的class属性获取，该fang'shi最为安全可靠，且程序性能最高。

    //类的class属性
Class classOne = User.class;
2. 已知某个类的实例，通过调用该实例的getClass方法获取Class对象。

   ```java
   //已有类对象的getClass方法
   Class collatz = user.getClass();

  1. 已知一个类的全类名，且该类在类路径下，可以通过静态方法forName()获取。

    Class c = Class.forName("com.demo.User");

  2. 内置基本数据类型可以直接使用类名.Type获取。

    //内置对象才有的TYPE属性，较大的局限性
Class<Integer> type = Integer.TYPE;

  3. 利用ClassLoader（类加载器）获取。

5.3可获得Class对象的类型

  1. class：外部类、成员（成员内部类，静态内部类），局部内部类，匿名内部类；

    //类可以反射
    Class c1 = Person.class;

  2. interface：所有接口；

    //接口可以反射
     Class c2 = Comparable.class;

  3. []：数组；

    //数组可以反射
     Class c3 = String[].class;
     Class c4 = int[][].class;

  4. enum：枚举；

    //枚举可以反射
     Class c6 = ElementType.class;

  5. annotation：注解（@interface）;

    //注解可以反射
     Class c5 = Data.class;

  6. 基本数据类型；

    //基本数据类型(包装类)可以反射
     Class c7 = int.class;
     Class c8 = Integer.class;

  7. void。

    //void可以反射
     Class c9 = void.class;

六、类的加载与ClassLoader

6.1类的加载过程

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

  1. 类的加载（Load）：将类的 class 文件字节码内容读入内存，并将这些静态数据转换成方法区运行时的数据结构，同时创建一个java.lang.Class对象，此过程由类加载器完成；

  2. 类的链接（Link）：将类的二进制数据合并到 JRE 中，确保加载的类信息符合 JVM 规范，同时 JVM 将常量池内的引用替换为地址。

  3. 类的初始化（Initialize）：JVM 负责对类进行初始化，分为类的主动引用和被动引用。

    • 类的主动引用
      • 虚拟器启动时，先初始化main方法所在的类；
      • new 类的对象；
      • 调用类的静态（static）成员和静态（static）方法；
      • 使用java.lang.reflect包的方法对类进行反射调用；
      • 如果该类的父类没有被初始化，则会先初始化它的父类。
    • 类的被动引用
      • 当访问到一个静态域时，只有真正声明这个域的类才会被初始化；
      • 通过数组定义类的引用，不会触发此类的初始化；
      • 引用常量不会触发此类的初始化

6.2类加载器

JVM支持两种类型的类加载器，分别为引导类加载器(BootstrapClassLoader)和自定义类加载器(User-Defined ClassLoader)。

从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类,类加载器。

但是Java虚拟机规范却没有这么定义,而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器。

无论类加载器的类型如何划分，在程序中我们最常见的类加载器始终只有3个，具体如下图所示：

类加载器

所以具体为引导类加载器(BootstrapClassLoader)和自定义类加载器（包括ExtensionClassLoader、Application ClassLoader（也叫System ClassLoader）、User Defined ClassLoader）。

public class Test03 {
    public static void main(String[] args) {
        //获取系统类的加载器
        ClassLoader sysLoader = ClassLoader.getSystemClassLoader();
        System.out.println(sysLoader);

        //获取系统类的父类加载器
        ClassLoader parent = sysLoader.getParent();
        System.out.println(parent);
    }
}

七、获取运行时类的完整对象

通过反射获取运行时类的完整结构：Field、Method、Constructor、Superless、Interface、Annotation等。

即：实现的全部接口、所继承的父类、全部的构造器、全部的方法、全部的成员变量（局部变量）、注解等。

/**
 */
public class Test04 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("com.demo.User");
        //获取所有属性
        Field field[];
        field = c1.getDeclaredFields();
        for (Field f:field){
            System.out.println(f);
        }
        //获得类的方法
        Method method[];
        method = c1.getDeclaredMethods();
        for (Method m:method){
            System.out.println(m);
        }
    }
}

八、反射获取泛型信息

Java 中采用泛型擦除的机制来引入泛型，Java 中的泛型仅仅是给编译器 javac 使用的，目的是确保数据的安全性以及免去强制类型转换的问题。一旦编译完成，所有和泛型相关的类型全部擦除。

在Java中可以通过反射获取泛型信息的场景有如下三个：

  • （1）成员变量的泛型
  • （2）方法参数的泛型
  • （3）方法返回值的泛型

在Java中不可以通过反射获取泛型信息的场景有如下两个：

  • （1）类或接口声明的泛型
  • （2）局部变量的泛型

要获取泛型信息，必须要注意ParameterizedType类，该类中的getActualTypeArguments()方法可以有效获取泛型信息。

下面以获取成员方法参数的泛型类型信息为例：

public class Demo {
    public static void main(String[] args) throws NoSuchMethodException, NoSuchFieldException {
 
        // 获取成员方法参数的泛型类型信息
        getMethodParametricGeneric();
    }
/**
     * 获取方法参数的泛型类型信息
     *
     * @throws NoSuchMethodException
     */
    public static void getMethodParametricGeneric() throws NoSuchMethodException {
        // 获取MyTestClass类中名为"setList"的方法
        Method setListMethod = MyClass.class.getMethod("setList", List.class);
        // 获取该方法的参数类型信息（带有泛型）
        Type[] genericParameterTypes = setListMethod.getGenericParameterTypes();
        // 但我们实际上需要获取返回值类型中的泛型信息，所以要进一步判断，即判断获取的返回值类型是否是参数化类型ParameterizedType
        for (Type genericParameterType : genericParameterTypes) {
            ParameterizedType parameterizedType = (ParameterizedType) genericParameterType;
            // 获取成员方法参数的泛型类型信息
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                Class realType = (Class) actualTypeArgument;
                System.out.println("成员方法参数的泛型信息：" + realType);
            }
        }
    }

九、反射获取注解信息

在开发中可能会遇到这样的场景：获取类的属性释义，这些释义定义在类属性的注解中。

/**
 * 定义一个实体类entity
 * */
@Data
class User{
    @ApiModelProperty(value = "姓名")
    private String userName;

    @ApiModelProperty(value = "用户id")
    private Long userId;

    @ApiModelProperty(value = "登录时间")
    private Date loginTime;
}

那么可以如何获取注解中的属性信息呢？

解决方案：

这里我们使用反射，以及java.lang下的两个方法：

//如果指定类型的注释存在于此元素上,  方法返回true 
java.lang.Package.isAnnotationPresent(Class<? extends Annotation> annotationClass) 
//如果是该类型的注释, 方法返回该元素的该类型的注释
java.lang.Package.getAnnotation(Class< A > annotationClass)
public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("com.demo.User");

        if(User.class.isAnnotationPresent(ApiModel.class)){
            System.out.println(User.class.getAnnotation(ApiModel.class).value());
        }
        // 获取类变量注解
        Field[] fields = User.class.getDeclaredFields();
        for (Field f : fields) {
            if(f.isAnnotationPresent(ApiModelProperty.class)){
                System.out.print(f.getAnnotation(ApiModelProperty.class).name() + ",");
            }
        }
    }

  • 拓展1：获取方法上的注解

    @Bean("sqlSessionFactory")
    public String test(@RequestBody User user) throws ClassNotFoundException {
        Class c2 = Class.forName("com.demo.User");
        // 获取方法注解：
        Method[] methods = User.class.getDeclaredMethods();
        for(Method m : methods){
            if (m.isAnnotationPresent((Class<? extends Annotation>) User.class)) {
                System.out.println(m.getAnnotation(ApiModelProperty.class).annotationType());
            }
        }
        return "test";
    }

  • 拓展2：获取方法参数上的注解

    @Bean("sqlSessionFactory")
    public String test(@RequestBody User user) throws ClassNotFoundException {
        Class c2 = Class.forName("com.demo.User");
        // 获取方法参数注解
        Method[] methods2 = User.class.getDeclaredMethods();
        for (Method m : methods2) {
            // 获取方法的所有参数
            Parameter[] parameters = m.getParameters();
            for (Parameter p : parameters) {
                // 判断是否存在注解
                if (p.isAnnotationPresent(ApiModelProperty.class)) {
                    System.out.println(p.getAnnotation(ApiModelProperty.class).name());
                }
            }
        }
        return "test";
    }

转自：https://www.cnblogs.com/Apluemxa/p/16354607.html

正文到此结束
所属分类：Spring家族
  • 本文链接： https://refblogs.com/article/328
  • 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
相关文章
热门推荐
评论插件初始化中...
Loading...
标签云
CICD 汇总 转换方法 快捷键 事务隔离级别 身份证号 替换方法 Linux 爬虫 静态类型 Hadoop Cookie 并发性能 抽象工厂模式 HTML5 语法 打包 创建表 查询 创建型设计模式 高级功能 使用技巧 JavaEE Python 算法解析 NIO 截取方法 设计原则 随心笔记 集群方案 Golang 字典 引用 构造函数 ChatGPT
本文目录