Java桥接方法 _java

千磨万击还坚劲，任尔东西南北风。这篇文章主要讲述Java桥接方法相关的知识，希望能为你提供帮助。

笔者在最近的日常工作中，因业务需要，研究 Java 字节码层面的知识。具体是，需要根据类字节码，获取特定方法名的方法入参，此方法名在源码中只有一个。但是在实际使用中发现：在类实现泛型接口的情况下，在字节码层面，类却有两个同名方法，导致无法确定哪个方法才是我们需要的方法。经过研究发现，其中一个方法是编译器在编译的过程中，自动生成的桥接方法(bridge method)，两个方法可通过特定标识区分。

注：此处的桥接方法，跟设计模式中的桥接模式，不是一个概念。
?问题描述?
为了能够说明问题，笔者模糊了实际业务场景的具体案例，用一个稍微简单，能够说明问题的示例，来分析编译器自动生成的桥接方法(bridge method)。
【Java桥接方法】我们知道，java 泛型是JDK 5 中引入的一个新特性，应用广泛。比如，我们有一个操作算子泛型接口 Operator，接口中有一个 process(T t) 方法，其作用是对入参 T 进行逻辑处理。示例代码如下：

/**
* @author renzhiqiang
* @date 2022/2/20 18:30
*/
public interface Operator
/**
* process method
* @param t
*/
void process(T t);

在实际业务场景中，我们会有不同的操作算子，实现Operator 接口，进行业务逻辑处理。那么我们来创建一个具体的算子，并实现Operator 接口，重写 process(T t) 方法。如下：

/**
* 用户信息算子
* @author renzhiqiang
* @date 2022/2/20 18:30
*/
public class UserInfoOperator implements Operator
@Override
public void process(String s)
// do something

其中，泛型接口中的入参类型 T，在实现类中替换成了实际需要的类型 java.lang.String。到这里，我们就准备好了代码样例。
那么，我们的目标是什么呢?就是要获取UserInfoOperator#process(String s) 方法的参数类型java.lang.String。读到这里，读者可能会想：这不很简单么，通过反射，根据Class#getDeclaredMethods()，获取到 UserInfoOperator 的所有方法，再找到方法名是 process 的方法，然后再获取到参数列表，不就可以获取参数类型java.lang.String 了么。
如果正在阅读文章的你也这么想的话，那请继续往下看。
根据 Java 反射方法Class#getDeclaredMethods() 的描述：
Returns an array of Method objectsincluding public, protected, default (package) access, and private methods, butexcludes inherited methods.
翻译过来就是：返回方法对象数组，包括公共方法、受保护方法、默认(包)访问方法和私有方法，但不包括继承方法。
根据我们的示例，如果我们通过反射，利用Class#getDeclaredMethods() 方法，我们预期的返回方法数组中，应该只有一个方法名是process 才对，但是这里却有两个 process 方法。惊不惊奇，意不意外!

?产生原因?
??编译器生成 bridge 方法??
我们知道，Java 源码需要经过编译器编译，生成对应的 .class 文件，才能给 JVM 使用。在源码中，我们只定义了一个名为 process 的方法。那么我们考虑，编译器在编译源码的过程中，是否会进行一些特的处理。为了更加直观的查看编译后的字节码文件，在 Idea 安装 jclasslib 插件，通过 jclasslib 查看 UserInfoOperator 和 Operator 的字节码。如下：

通过 jclasslib 查看 .class 文件发现，在 UserInfoOperator 类中确实存在两个 process 方法：其中一个方法入参是 java.lang.String，另一个方法的入参是 java.lang.Object。而在 Operator 字节码中，只有一个 process 方法，方法的入参是 java.lang.Object。同时我们注意到，在 UserInfoOperator 类的字节码中， [访问标志]项，其中一个方法的访问标志是 [public synthetic bridge]。其中 public 很好理解，但是其中的 [synthetic bridge] 是怎么来的呢?
查阅相关资料后发现，标识符 synthetic ，表示此方法是否是由编译器自动产生的; 标识符 bridge，表示此方法是否是由编译器产生的桥接方法。

到此，可以确定的是，其中一个process 方法，是编译器自动产生的桥接方法。那么为什么编译器会产生桥接方法呢?以及在什么情况下，会产生桥接方法?以及如何判断一个方法是不是桥接方法?我们继续往下分析。
?为何生成 bridge 方法?
??正确编译??
在源码中，Operator 类的 process 方法的参数定义是 process(T t)，参数类型是 T。而在字节码层面我们看到，process 方法在编译之后，编译器将入参类型变成了 java.lang.Object。伪代码示意，大概是这样：

public interface Operator
/**
* 方法参数变成 Object 类型
* @param object
*/
void process(Object object);

想象一下，如果没有编译器自动生成的桥接方法，那么在编译层面是不能通过的：因为接口 Operator 中的 process 方法,，经过编译之后，参数类型变成了 java.lang.Object 类型，而实现类 UserInfoOperator 中的 process 方法的参数是 java.lang.String 类型，两者的方法参数不一致，导致UserInfoOperator 并没有重写接口中的 process 方法，因此编译无法通过。
这种情况下，编译器自动生成一个桥接方法 void process(Object obj) 方法，则可以编译通过，似乎是理所当然的事情。自动生成的 process方法，方法签名为：void process(Object object)。伪代码示意，大概是这样：

// 自动生成的process 方法
public void process(Object object)
process((String) object);

??类型擦除??
我们知道，Java 中的泛型在编译期间会将泛型信息擦除。如代码定义 List 和 List，编译之后都会变成 List。我们再考虑一种常见的情形：Java 类库中比较器的用法。我们自定义比较器的时候，可以通过实现 Comparator 接口，实现比较逻辑。示例代码如下：

public class MyComparator implements Comparator
public int compare(Integer a,Integer b)
// 比较逻辑

这种情况下，编译器同样会产生一个桥接方法。方法签名为 intcompare(Object a, Object b) 。

伪代码示意，大概是这样：

public class MyComparator implements Comparator
public int compare(Integer a,Integer b)
// 比较逻辑

// 桥接方法 (bridge method)
public int compare(Object a,Object b)
return compare((Integer)a,(Integer)b);

因此，当我们使用如下方式进行比较的时候，能够通过编译并得到我们预期的结果：

Object a = 5;
Object b = 6;
Comparator rawComp = new MyComparator();
// 可以通过编译，因为自动生成了桥接方法compare(Object a, Object b)
int comp = rawComp.compare(a, b);

另外，我们知道，泛型编译之后，类型信息会被擦除。如果我们有这样一个比较方法：

// 比较方法
publicT max(List list, Comparator comparator)
T biggestSoFar = list.get(0);
for ( T t : list )
if (comparator.compare(t,biggestSoFar) > 0)
biggestSoFar = t;

return biggestSoFar;

编译之后，泛型被擦除掉，伪代码表示，大概是这样：

public Object max(List list, Comparator comparator)
Object biggestSoFar =list.get(0);
for ( Objectt : list )
if (comparator.compare(t,biggestSoFar) > 0)//比较逻辑
biggestSoFar = t;

return biggestSoFar;

我们将 MyComparator 其中一个参数传入 max() 方法。如果没有桥接方法的话，那么第四行的比较逻辑，将无法正确编译，因为MyComparator 类中没有两个参数是 Object 类型的比较方法，只有参数类型是 Integer 类型的比较方法。读者可自行测试。
?解决方案?
通过以上的案例描述，我们知道，在实现泛型接口的场景下，编译器会自动生成桥接方法，保证编译能够通过。那么在这种情况下，我们只要识别哪一个是桥接方法，哪一个不是桥接方法，就可以解决我们一开始的问题。很自然的，既然编译器自动产生了一个桥接方法，那么应该会有某种方式，可以让我们判断一个方法是否是桥接方法。
果然，我们继续研究发现，Method 类中提供了 Method#isBridge() 方法。查看源码中对方法的描述：Method#isBridge()：Returns true if this method is a bridge method; returns false otherwise。
到此，我们通过反射，获取到 UserInfoOperator 类中的两个process 方法，再调用 Method#isBridge() 方法，即可锁定需要的方法，因而进一步获取方法参数 java.lang.String。
?深入分析?
至此可以说，就业务需求来说，我们完美的找到了解决方案。但在此之后，不禁会想：除了上述示例，还有哪些情况下，编译器也会自动生成桥接方法呢?我们继续深入研究。
??类继承??
通过查阅相关资料，我们考虑如下一种情况：

/**
* 如下会产生桥接方法吗？
* @author renzhiqiang
* @date 2022/2/20 18:33
*/
public class BridgeMethodSample
static class A
public void foo()

public static class C extends A

public static class D extends A
@Override
public void foo()

上述代码示例中，我们定义了三个静态内部类：A C D，其中 C D 分别继承 A。经过编译，通过jclasslib 查看 BridgeMethodSample 字节码，我们也发现：类 C 中编译器为其生成了桥接方法 void foo()，而类 D 中却没有。

深入分析，并根据上述分析的经验，我们猜测，编译器生成桥接方法，一定是在某种情况下需要一个方法，来满足 Java 编程规范，或者需要保证程序运行的正确性。通过字节码可以看出，类 A 没有 public 修饰，包范围以外的程序是没有访问类 A 的权限的，更不用说类 A 中的方法。
但是类 C 是有public 修饰，C 类中的方法，包括继承来的方法，是可以被包外的程序访问的。因此，编译器需要生成一个桥接方法，以保证能够访问 foo() 方法，满足程序的正确运行。但是，类 D 同样继承 A，却没有生成桥接方法，根本原因是类 D 中重写了父类 A 中的 foo() 方法，即没有必要生成桥接方法。
?方法重写?
我们再看一种情况，方法重写。
Java 中，方法重写(Override)，是子类对父类的允许访问的方法的实现过程进行重新编写的过程。重写需要满足一定的规则：

1. The method must have the same name as in the parentclass.2. The method must have the same parameter as in theparent class.3. There must be an IS-A relationship (inheritance).JDK 5 之后，重写方法的返回类型，可以与父类方法返回类型相同，也可以不相同，但必须是父类方法返回类型的子类。我们考虑如下代码示例：

// 定义一个父类，包含一个 test() 方法
public class Father
public Object test(String s)
return s;

// 定义一个子类，继承父类
public class Child extends Father
@Override
public String test(String s)
return s;

以上，在 Child 子类中，我们重写了 test() 方法，但是返回值的类型，我们将 java.lang.Object 改变为它的子类 java.lang.String。编译之后，我们同样使用 jclasslib 插件，查看两个类的字节码，如下所示：

根据上图我们发现，Child 类中我们重写了 test() 方法，但是在字节码层面，发现有两个 test() 方法，其中一个方法的访问标志为 [public synthetic bridge]，表示这个方法是编译器为我们生成的。而当我们不改变 Child#test() 方法的返回类型时，编译器并没有为我们生成桥接方法，读者可自行试验。
也就是说，在子类方法重写父类方法，返回类型不一致的情况下，编译器也为我们生成了桥接方法。
以上，笔者罗列了几种编译器为我们自动生成桥接方法的情况。那么是否还有其他场景下，编译器也会生成桥接方法呢?如果您也曾研究过或者使用过 bridge 方法，欢迎交流讨论。