0%

反射、注解和泛型在OOP场景注意事项

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 11k 阅读时长 ≈ 10 分钟

接下来，我们就通过几个案例，看看这三大特性结合 OOP 使用时会有哪些坑吧。

1. 反射调用方法不是以传参决定重载

反射的功能包括，在运行时动态获取类和类成员定义，以及动态读取属性调用方法。也就是说，针对类动态调用方法，不管类中字段和方法怎么变动，我们都可以用相同的规则来读取信息和执行方法。因此，几乎所有的 ORM（对象关系映射）、对象映射、MVC 框架都使用了反射。

反射的起点是 Class 类，Class 类提供了各种方法帮我们查询它的信息。接下来，我们先看一个反射调用方法遇到重载的坑：有两个叫 age 的方法，入参分别是基本类型 int 和包装类型 Integer。

1
2
3
4
5
6
7
8
9
@Slf4j
public class ReflectionIssueApplication {
    private void age(int age) {
        log.info("int age = {}", age);
    }
    private void age(Integer age) {
        log.info("Integer age = {}", age);
    }
}

如果不通过反射调用，走哪个重载方法很清晰，比如传入 36 走 int 参数的重载方法，传入 Integer.valueOf(“36”) 走 Integer 重载：

1
2
3
ReflectionIssueApplication application = new ReflectionIssueApplication();
application.age(36);
application.age(Integer.valueOf("36"));

但使用反射时的误区是，认为反射调用方法还是根据入参确定方法重载。比如，使用 getDeclaredMethod 来获取 age 方法，然后传入 Integer.valueOf(“36”)：

1
2
3
4
5
6
7
8
9
10
public class ReflectionDemo {

    @Test
    public void test1() throws Exception {
        Class<?> clazz = Class.forName("com.shoto.error.oop.ReflectionIssueApplication");
        Method ageMethod = clazz.getDeclaredMethod("age", Integer.TYPE);
        ageMethod.setAccessible(true);
        ageMethod.invoke(clazz.newInstance(), Integer.valueOf("36"));
    }
}

输出的日志证明，走的是 int 重载方法：

1
22:29:32.154 [main] INFO com.shoto.error.oop.ReflectionIssueApplication - int age = 36

其实，要通过反射进行方法调用，第一步就是通过方法签名来确定方法。具体到这个案例， getDeclaredMethod 传入的参数类型 Integer.TYPE 代表的是 int，所以实际执行方法时无论传的是包装类型还是基本类型，都会调用 int 入参的 age 方法。

把 Integer.TYPE 改为 Integer.class，执行的参数类型就是包装类型的 Integer。这时，无论传入的是 Integer.valueOf(“36”) 还是基本类型的 36：

1
2
3
4
5
6
7
8
@Test
public void test3() throws Exception {
    Class<?> clazz = Class.forName("com.shoto.error.oop.ReflectionIssueApplication");
    Method ageMethod = clazz.getDeclaredMethod("age", Integer.class);
    ageMethod.setAccessible(true);
    ageMethod.invoke(clazz.newInstance(), Integer.valueOf("36"));
    ageMethod.invoke(clazz.newInstance(), 36);
}

都会调用 Integer 为入参的 age 方法：

1
2
22:31:06.174 [main] INFO com.shoto.error.oop.ReflectionIssueApplication - Integer age = 36
22:31:06.178 [main] INFO com.shoto.error.oop.ReflectionIssueApplication - Integer age = 36

现在我们非常清楚了，反射调用方法，是以反射获取方法时传入的方法名称和参数类型来确 定调用方法的。接下来，我们再来看一下反射、泛型擦除和继承结合在一起会碰撞出什么 坑。

2. 泛型经过类型擦除多出桥接方法的坑

Java 编译器对泛型应用了强大的类型检测，如果代码违反了类型安全就会报错，可以在编译时暴露大多数泛型的编码错误。但总有一部分编码错误，比如泛型类型擦除的坑，在运行时才会暴露。接下来，我就和你分享一个案例吧。

有一个项目希望在类字段内容变动时记录日志，于是开发同学就想到定义一个泛型父类，并在父类中定义一个统一的日志记录方法，子类可以通过继承重用这个方法。代码上线后业务没啥问题，但总是出现日志重复记录的问题。开始时，我们怀疑是日志框架的问题，排查到最后才发现是泛型的问题，反复修改多次才解决了这个问题。

父类是这样的：有一个泛型占位符 T；有一个 AtomicInteger 计数器，用来记录 value 字 段更新的次数，其中 value 字段是泛型 T 类型的，setValue 方法每次为 value 赋值时对计数器进行 +1 操作。我重写了 toString 方法，输出 value 字段的值和计数器的值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Parent<T> {
    //用于记录value更新的次数，模拟日志记录的逻辑
    private AtomicInteger updateCount = new AtomicInteger();
    private T value;

    //重写toString，输出值和值更新次数
    @Override
    public String toString() {
        return String.format("value: %s updateCount: %d", value, updateCount.get());
    }

    //设置值
    public void setValue(T value) {
        System.out.println("Parent.setValue called");
        this.value = value;
        updateCount.incrementAndGet();
    }
}

子类 Child1 的实现是这样的：继承父类，但没有提供父类泛型参数；定义了一个参数为 String 的 setValue 方法，通过 super.setValue 调用父类方法实现日志记录。我们也能明白，开发同学这么设计是希望覆盖父类的 setValue 实现：

1
2
3
4
5
6
public class Child1 extends Parent {
    public void setValue(String value) {
        System.out.println("Child1.setValue called");
        super.setValue(value);
    }
}

在实现的时候，子类方法的调用是通过反射进行的。实例化 Child1 类型后，通过 getClass().getMethods 方法获得所有的方法；然后按照方法名过滤出 setValue 方法进行调用，传入字符串 test 作为参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
public void test4() {
    Child1 child1 = new Child1();
    Arrays.stream(child1.getClass().getMethods())
        .filter(method -> method.getName().equals("setValue"))
        .forEach(method -> {
            try {
                method.invoke(child1, "test");
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    System.out.println(child1.toString());
}

运行代码后可以看到，虽然 Parent 的 value 字段正确设置了 test，但父类的 setValue 方 法调用了两次，计数器也显示 2 而不是 1：

1
2
3
4
Child1.setValue called
Parent.setValue called
Parent.setValue called
value: test updateCount: 2

显然，两次 Parent 的 setValue 方法调用，是因为 getMethods 方法找到了两个名为 setValue 的方法，分别是父类和子类的 setValue 方法。

这个案例中，子类方法重写父类方法失败的原因，包括两方面：

一是，子类没有指定 String 泛型参数，父类的泛型方法 setValue(T value) 在泛型擦除后是 setValue(Object value)，子类中入参是 String 的 setValue 方法被当作了新方法；

二是，子类的 setValue 方法没有增加 @Override 注解，因此编译器没能检测到重写失败的问题。这就说明，重写子类方法时，标记 @Override 是一个好习惯。

下面学重新实现了 Child2，继承 Parent 的时候提供了 String 作为泛型 T 类型，并使用 @Override 关键字注释了 setValue 方 法，实现了真正有效的方法重写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Child2 extends Parent<String> {
    @Override
    public void setValue(String value) {
        System.out.println("Child2.setValue called");
        super.setValue(value);
    }
}

@Test
public void test5() {
    Child1 child1 = new Child1();
    // getDeclaredMethods 只获取当前类的方法
    Arrays.stream(child1.getClass().getDeclaredMethods())
        .filter(method -> method.getName().equals("setValue"))
        .forEach(method -> {
            try {
                method.invoke(child1, "test");
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    System.out.println(child1.toString());
}

但很可惜，修复代码上线后，还是出现了日志重复记录：

1
2
3
4
5
Child2.setValue called
Parent.setValue called
Child2.setValue called
Parent.setValue called
value: test updateCount: 2

可以看到，这次是 Child2 类的 setValue 方法被调用了两次。通过 getDeclaredMethods 查找到的方法一定是来自 Child2 类本身；而且，怎么看 Child2 类中也只有一个 setValue 方法，为什么还会重复呢？

调试一下可以发现，Child2 类其实有 2 个 setValue 方法，入参分别是 String 和 Object。如果不通过反射来调用方法，我们确实很难发现这个问题。其实，这就是泛型类型擦除导致 的问题。我们来分析一下。

image-20220902223848571

我们知道，Java 的泛型类型在编译后擦除为 Object。虽然子类指定了父类泛型 T 类型是 String，但编译后 T 会被擦除成为 Object，所以父类 setValue 方法的入参是 Object， value 也是 Object。如果子类 Child2 的 setValue 方法要覆盖父类的 setValue 方法，那入参也必须是 Object。所以，编译器会为我们生成一个所谓的 bridge 桥接方法，你可以使用 javap 命令来反编译编译后的 Child2 类的 class 字节码：

image-20220902224738813

可以看到，入参为 Object 的 setValue 方法在内部调用了入参为 String 的 setValue 方法，也就是代码里实现的那个方法。如果编译器没有帮我们实现这个桥接方法，那么 Child2 子类重写的是父类经过泛型类型擦除后、入参是 Object 的 setValue 方法。这两个方法的参数，一个是 String 一个是 Object，明显不符合 Java 的语义：

知道这个问题之后，修改方式就明朗了，可以使用 method 的 isBridge 方法，来判断方法是不是桥接方法：

通过 getDeclaredMethods 方法获取到所有方法后，必须同时根据方法名 setValue 和 非 isBridge 两个条件过滤，才能实现唯一过滤；使用 Stream 时，如果希望只匹配 0 或 1 项的话，可以考虑配合 ifPresent 来使用 findFirst 方法。

修复代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
public void test7() {
    Child2 child2 = new Child2();
    Arrays.stream(child2.getClass().getDeclaredMethods())
        .filter(method -> method.getName().equals("setValue") && !method.isBridge())
        .findFirst().ifPresent(method -> {
        try {
            method.invoke(child2, "test");
        } catch (Exception e) {
            e.printStackTrace();
        }
    });
    System.out.println(child2.toString());
}

这样就可以得到正确输出了：

1
2
3
Child2.setValue called
Parent.setValue called
value: test updateCount: 1

最后小结下，使用反射查询类方法清单时，我们要注意两点：

  • getMethods 和 getDeclaredMethods 是有区别的，前者可以查询到父类方法，后者只能查询到当前类。
  • 反射进行方法调用要注意过滤桥接方法。

3. 注解可以继承吗？

注解可以为 Java 代码提供元数据，各种框架也都会利用注解来暴露功能，比如 Spring 框架中的 @Service、@Controller、@Bean 注解，Spring Boot 的 @SpringBootApplication 注解。

框架可以通过类或方法等元素上标记的注解，来了解它们的功能或特性，并以此来启用或执行相应的功能。通过注解而不是 API 调用来配置框架，属于声明式交互，可以简化框架的配置工作，也可以和框架解耦。

开发同学可能会认为，类继承后，类的注解也可以继承，子类重写父类方法后，父类方法上的注解也能作用于子类，但这些观点其实是错误或者说是不全面的。我们来验证下吧。

首先，定义一个包含 value 属性的 MyAnnotation 注解，可以标记在方法或类上：

1
2
3
4
5
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value();
}

然后，定义一个标记了 @MyAnnotation 注解的父类 Person，设置 value 为 Class 字符 串；同时这个类的 foo 方法也标记了 @MyAnnotation 注解，设置 value 为 Method 字 符串。接下来，定义一个子类 Student 继承 Person父类，并重写父类的 foo 方法，子类的 foo 方法和类上都没有 @MyAnnotation 注解。

1
2
3
4
5
6
7
8
9
10
11
12
13
@MyAnnotation(value = "Class")
@Slf4j
public class Person {
    @MyAnnotation(value = "Method")
    public void foo() {
    }
}
@Slf4j
public class Student extends Person {
    @Override
    public void foo() {
    }
}

再接下来，通过反射分别获取 Parent 和 Child 的类和方法的注解信息，并输出注解的 value 属性的值（如果注解不存在则输出空字符串）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Slf4j
public class AnnotationDemo {

    @Test
    public void test1() throws NoSuchMethodException {
        //获取父类的类和方法上的注解
        Person person = new Person();
        log.info("ParentClass:{}", getAnnotationValue(person.getClass().getAnnotation(MyAnnotation.class)));
        log.info("ParentMethod:{}", getAnnotationValue(person.getClass().getMethod("foo").getAnnotation(MyAnnotation.class)));
        //获取子类的类和方法上的注解
        Student student = new Student();
        log.info("ChildClass:{}", getAnnotationValue(student.getClass().getAnnotation(MyAnnotation.class)));
        log.info("ChildMethod:{}", getAnnotationValue(student.getClass().getMethod("foo").getAnnotation(MyAnnotation.class)));

    }

    private String getAnnotationValue(MyAnnotation annotation) {
        if (annotation == null) return "";
        return annotation.value();
    }
}

输出如下：

1
2
3
4
23:11:47.607 [main] INFO com.shoto.error.oop.AnnotationDemo - ParentClass:Class
23:11:47.610 [main] INFO com.shoto.error.oop.AnnotationDemo - ParentMethod:Method
23:11:47.611 [main] INFO com.shoto.error.oop.AnnotationDemo - ChildClass:
23:11:47.611 [main] INFO com.shoto.error.oop.AnnotationDemo - ChildMethod:

可以看到，父类的类和方法上的注解都可以正确获得，但是子类的类和方法却不能。这说明，子类以及子类的方法，无法自动继承父类和父类方法上的注解。

如果你详细了解过注解应该知道，在注解上标记 @Inherited 元注解可以实现注解的继承。 那么，把 @MyAnnotation 注解标记了 @Inherited，就可以一键解决问题了吗？

1
2
3
4
5
6
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface MyAnnotation {
    String value();
}

重新运行代码输出如下：

1
2
3
4
23:14:54.255 [main] INFO com.shoto.error.oop.AnnotationDemo - ParentClass:Class
23:14:54.259 [main] INFO com.shoto.error.oop.AnnotationDemo - ParentMethod:Method
23:14:54.259 [main] INFO com.shoto.error.oop.AnnotationDemo - ChildClass:Class
23:14:54.259 [main] INFO com.shoto.error.oop.AnnotationDemo - ChildMethod:

可以看到，子类可以获得父类类上的注解；子类 foo 方法虽然是重写父类方法，并且注解本身也支持继承，但还是无法获得方法上的注解。

如果你再仔细阅读一下@Inherited 的文档就会发现，@Inherited 只能实现类上的注解继承。要想实现方法上注解的继承，你可以通过反射在继承链上找到方法上的注解。但，这样实现起来很繁琐，而且需要考虑桥接方法。

好在 Spring 提供了 AnnotatedElementUtils 类，来方便我们处理注解的继承问题。这个类的 findMergedAnnotation 工具方法，可以帮助我们找出父类和接口、父类方法和接口方法上的注解，并可以处理桥接方法，实现一键找到继承链的注解：

1
2
3
4
5
6
@Test
public void test2() throws NoSuchMethodException {
    Student student = new Student();
    log.info("ChildClass:{}", getAnnotationValue(AnnotatedElementUtils.findMergedAnnotation(student.getClass(), MyAnnotation.class)));
    log.info("ChildMethod:{}", getAnnotationValue(AnnotatedElementUtils.findMergedAnnotation(student.getClass().getMethod("foo"), MyAnnotation.class)));
}

修改后，可以得到如下输出：

1
2
23:21:43.399 [main] INFO com.shoto.error.oop.AnnotationDemo - ChildClass:Class
23:21:43.404 [main] INFO com.shoto.error.oop.AnnotationDemo - ChildMethod:Method

可以看到，子类 foo 方法也获得了父类方法上的注解。

------ 本文结束------