泛型擦除，桥接方法介绍

小灰灰 2022-12-13 04:37 153阅读 0赞

## 1：简答说明 ##

泛型是在jdk5才引入的一种编译时的一种机制，实现了`类级别参数的动态传入`。另外关于如何获取桥接方法的原始方法可以参考这个方法`org.springframework.core.BridgeMethodResolver#findBridgedMethod`。

## 2：方法重载 ##

为了更好的理解泛型擦除，桥接方法，这里我们先看下方法重载。当一个类中的方法签名除了参数类型不同，其它都相同的时候，我们叫做是方法重载。我们先定义如下的类：

public class MethodOverload { 
    
        public void sayHi(Object param) { 
            System.out.println("Object param is: " + param);
        }
    
        public void sayHi(int param) { 
            System.out.println("int param is: " + param);
        }
    
        public void sayHi(String param) { 
            System.out.println("String param is: " + param);
        }
    }

`sayHi`方法被重载了三次，接收的参数分别是`Object`,`int`,`String`，通过`javap -v -p`查看编译生成的字节码信息：

public void sayHi(java.lang.Object);
        descriptor: (Ljava/lang/Object;)V
        flags: ACC_PUBLIC
        ...
      public void sayHi(int);
        descriptor: (I)V
        flags: ACC_PUBLIC
        ...
      public void sayHi(java.lang.String);
        descriptor: (Ljava/lang/String;)V
        flags: ACC_PUBLIC
        ...

可以看到方法和方法描述符`descriptor`对应关系如下：  
`public void sayHi(java.lang.Object)` \-> `descriptor: (Ljava/lang/Object;)V`  
`public void sayHi(int)` \-> `descriptor: (I)V`  
`public void sayHi(java.lang.String)` \-> `descriptor: (Ljava/lang/String;)V`  
然后我们定义测试代码调用这些方法：

public class MethodOverloadTest { 
    
        public static void main(String[] args) { 
            MethodOverload  methodOverload = new MethodOverload();
            int intParam = 100;
            methodOverload.sayHi(intParam);
            String stringParam = "100";
            methodOverload.sayHi(stringParam);
            Long longParam = 100L;
            methodOverload.sayHi(longParam);
        }
    }

jvm在选择目标方法时是根据方法描述符`descriptor`的匹配程度来确定最终要调用的方法的，因此参数`int intParam = 100;`的方法自然是找到方法描述符`descriptor`为`descriptor: (I)V`的方法`public void sayHi(int)`,而参数`Long longParam = 100L;`又会调用哪个方法呢，目标方法描述符并没有参数类型完全匹配的方法，此时会选择参数类型为其`上限类型`的目标方法，因此最终会选择方法描述符`descriptor`为`descriptor: (Ljava/lang/Object;)V`的方法`public void sayHi(java.lang.Object);`,直接看运行效果：

int param is: 100
    String param is: 100
    Object param is: 100

那么对于参数`long longParam = 100L;`我们如果添加如下的重载方法（直接附字节码信息）：

public void sayHi(Number param) { 
        System.out.println("Number param is: " + param);
    }
    
    public void sayHi(java.lang.Number);
     descriptor: (Ljava/lang/Number;)V
     flags: ACC_PUBLIC

此时参数类型`java.lang.Long`的上限类型就变成了`java.lang.Number`：  
`public final class Long extends Number implements Comparable<Long>`，因此最终执行结果变为：

int param is: 100
    String param is: 100
    Number param is: 100

## 3：泛型擦除 ##

### 3.1：定义 ###

编译后的字节码不体现泛型的任何信息就叫做是`泛型擦除`，接下来具体看下例子。

### 3.2：有泛型的类 ###

定义如下的类：

public class GenericWithNoExtend<T> { 
    
        public String sayHi(T param) { 
            System.out.println(param);
            return "AAA";
        }
    }

查看字节码信息：

public java.lang.String sayHi(T);
      descriptor: (Ljava/lang/Object;)Ljava/lang/String;
      flags: ACC_PUBLIC

可以看到生成的方法描述符`descriptor`是`descriptor: (Ljava/lang/Object;)Ljava/lang/String;`，泛型的痕迹已经被擦除掉了，这就叫做泛型擦除，那么这里参数`Ljava/lang/Object;`又是怎么确定的呢？其实就是取其`上限类型`，因为我们写的是`<T>`，其实相当于是`<T extends Object>`,其实此时和定义方法`public java.lang.String sayHi(Object param);`对于jvm来说是等价的。那么如果我添加这个方法会怎么样呢？其实是会在编译时报错的，因为在泛型擦除后，两个方法就完全相同了，如下:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70_pic_center]  
既然带有泛型的方法是由其`上限类型`决定其方法描述符`descriptor`的，那么我们修改`<T>`为`<T extends Customer>`会怎样呢，结果其实就是参数类型变为了`Custom`，如下：

public class Merchant <T extends Customer> { 
    
        public double actionPrice(T customer) { 
            return 0.0d;
        }
    }
    
    public double actionPrice(T);
     descriptor: (Lgeek/jvm/Customer;)D
     flags: ACC_PUBLIC

可以看到方法描述符变成了`descriptor: (Lgeek/jvm/Customer;)D`。

## 4：桥接方法 ##

### 4.1：定义 ###

桥接方法是编译器自动生成的打了`ACC_BRIDGE`,`ACC_SYNTHETIC`的`flags`的方法，如`flags: ACC_PUBLIC, ACC_BRIDGE, ACC_SYNTHETIC`。

### 4.2：定义泛型类 ###

public class Merchant <T extends Customer> { 
    
        public double actionPrice(T customer) { 
            return 0.0d;
        }
    }
    
    public class VIP extends Customer { 
    }

### 4.3：定义泛型类子类 ###

public class VIPOnlyMerchant extends Merchant<VIP> { 
    
        @Override
        public double actionPrice(VIP customer) { 
            return 0.0d;
        }
    }

### 4.4：查看字节码信息 ###

首先查看父类`Merchant`的字节码信息：

public double actionPrice(T);
        descriptor: (Lyanshenzhishi/bridgemethodtest/Customer;)D
        flags: ACC_PUBLIC

再查看子类`VIPOnlyMerchant`的字节码信息：

public double actionPrice(yanshenzhishi.bridgemethodtest.VIP);
       descriptor: (Lyanshenzhishi/bridgemethodtest/VIP;)D
       flags: ACC_PUBLIC
        
     public double actionPrice(yanshenzhishi.bridgemethodtest.Customer);
        descriptor: (Lyanshenzhishi/bridgemethodtest/Customer;)D
        flags: ACC_PUBLIC, ACC_BRIDGE, ACC_SYNTHETIC
        Code:
          stack=2, locals=2, args_size=2
             0: aload_0
             1: aload_1
             2: checkcast     #2                  // class yanshenzhishi/bridgemethodtest/VIP
             5: invokevirtual #3                  // Method actionPrice:(Lyanshenzhishi/bridgemethodtest/VIP;)D
             8: dreturn

注意其中flags中有`ACC_BRIDGE`就是编译器自动生成的桥接方法。另外我们看指令`2: checkcast #2`，是将参数类型强转为`#2`，其中`#2`的信息如下：

#2 = Class              #23
    #23 = Utf8               yanshenzhishi/bridgemethodtest/VIP

可以看到是强转为`yanshenzhishi/bridgemethodtest/VIP`类型。然后又执行了指令`5: invokevirtual #3`，代表调用了类实例方法`#3`，其中`#3`信息如下：

#3 = Methodref          #4.#24
      #4 = Class              #25
      #24 = NameAndType        #13:#14
      #13 = Utf8               actionPrice
      #14 = Utf8               (Lyanshenzhishi/bridgemethodtest/VIP;)D
      #24 = NameAndType        #13:#14

意思就是`yanshenzhishi/bridgemethodtest/VIPOnlyMerchant.actionPrice:(Lyanshenzhishi/bridgemethodtest/VIP;)D`其实就是调用了我们定义的方法`public double actionPrice(VIP customer)`,该桥接方法大概等同于如下代码：

public double actionPrice(Custom customer) { 
    	VIP vip = (VIP)customer;
    	actionPrice(vip);
    }

注意这里我们是重载父类`Merchant`的`adtionPrice`方法，如果是按照现有的方法定义明显是不满足重载要求的，因为参数类型不同，所以为了满足方法重载的语法要求，编译器自动生成了一个`满足重载要求的桥接方法`。通过如下代码获取方法名称为`actionPrice`的所有方法：

Class<VIPOnlyMerchant> vipOnlyMerchantClass = VIPOnlyMerchant.class;
      Method[] methods = vipOnlyMerchantClass.getMethods();
      for (Method method : methods) { 
          if (method.getName().equalsIgnoreCase("actionPrice")) { 
              // 是否为桥接方法
              System.out.println(method.isBridge());
              System.out.println("方法是：" + method);
          }
      }

输出：

false
    方法是：public double yanshenzhishi.bridgemethodtest.VIPOnlyMerchant.actionPrice(yanshenzhishi.bridgemethodtest.VIP)
    true
    方法是：public double yanshenzhishi.bridgemethodtest.VIPOnlyMerchant.actionPrice(yanshenzhishi.bridgemethodtest.Customer)

可以看到有2个方法，其中第二个就是编译器自动生成的桥接方法。

## 5：为什么要有桥接方法 ##

主要有两个原因：

1：为了兼容jdk5之前字节码的格式。
    2：因为泛型擦除后，泛型方法的参数会变成泛型的上限类型，子类重载的父类方法因为参数类型不同其实是不符合重载的语法要求的，为了满足重载的语法要求，这里通过生成桥接方法来完成。

## 最后：都让开，我要喝瑞幸 ##

![在这里插入图片描述][20200828090303329.png_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/dcafd164f302494e84853fa5f14ec21c.png
[20200828090303329.png_pic_center]: /images/20221123/6096374712b44eceb8c614a3485be306.png