java 桥接方法

阳光穿透心脏的1/2处 2021-09-02 07:14 276阅读 0赞

#### java泛型 ####

泛型是在jdk1.5时引入的，java泛型其实不能说是真正的泛型，因为它在JVM运行期是不存在泛型的。java泛型是在编译期做的，将泛型类型擦除，用到的时候又强制转换为需要的类型。  
看个例子，打印日志，日志内容是泛型：

public class PrintLog<T> { 
    
    	public static final Logger log = LoggerFactory.getLogger(PrintLog.class);
    
    	protected T logContent;
    
    	public void printLog(T logContent) { 
    		log.info("logContent:{}", logContent);
    	}
    
    	@Override
    	public String toString() { 
    		return ReflectionToStringBuilder.toString(this);
    	}
    }

这是一个泛型类，我们通过javap命令看一下编译后的字节码（部分）

public void printLog(T);
       descriptor: (Ljava/lang/Object;)V
       flags: ACC_PUBLIC
       Code:
         stack=3, locals=2, args_size=2
            0: getstatic     #2                  // Field log:Lorg/slf4j/Logger;
            3: ldc           #3                  // String logContent:{}
            5: aload_1
            6: invokeinterface #4,  3            // InterfaceMethod org/slf4j/Logge
    .info:(Ljava/lang/String;Ljava/lang/Object;)V
           11: return
         LineNumberTable:
           line 14: 0
           line 15: 11
         LocalVariableTable:
           Start  Length  Slot  Name   Signature
               0      12     0  this   Lreflection/generic/PrintLog;
               0      12     1 logContent   Ljava/lang/Object;
         LocalVariableTypeTable:
           Start  Length  Slot  Name   Signature
               0      12     0  this   Lreflection/generic/PrintLog<TT;>;
               0      12     1 logContent   TT;
       Signature: #26                          // (TT;)V

我们可以看到 descriptor: (Ljava/lang/Object;)V,编译后的参数类型是Object。这就是泛型的类型擦除。

#### 桥接方法 ####

当我们对PrintLog新增一个子类，并重写printLog方法。

public class PrintLogChild2 extends PrintLog<String> { 
    
    	@Override
    	public void printLog(String logContent) { 
    		super.printLog(logContent);
    	}
    }

我们看一下PrintLogChild2 的字节码：

// 构造函数
      public reflection.generic.PrintLogChild2();
        descriptor: ()V
        flags: ACC_PUBLIC
        Code:
          stack=1, locals=1, args_size=1
             0: aload_0
             1: invokespecial #1                  // Method reflection/generic/PrinLog."<init>":()V
             4: return
          LineNumberTable:
            line 3: 0
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0       5     0  this   Lreflection/generic/PrintLogChild2;
      
      // 原函数
      public void printLog(java.lang.String);
        descriptor: (Ljava/lang/String;)V
        flags: ACC_PUBLIC
        Code:
          stack=2, locals=2, args_size=2
             0: aload_0
             1: aload_1
             2: invokespecial #2                  // Method reflection/generic/PrintLog.printLog:(Ljava/lang/Object;)V
             5: return
          LineNumberTable:
            line 7: 0
            line 8: 5
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0       6     0  this   Lreflection/generic/PrintLogChild2;
                0       6     1 logContent   Ljava/lang/String;
    
      // 编译期生成的桥接函数 
      public void printLog(java.lang.Object);
        descriptor: (Ljava/lang/Object;)V
        flags: ACC_PUBLIC, ACC_BRIDGE, ACC_SYNTHETIC
        Code:
          stack=2, locals=2, args_size=2
             0: aload_0
             1: aload_1
             2: checkcast     #3                  // class java/lang/String
             5: invokevirtual #4                  // Method printLog:(Ljava/lang/Sting;)V
             8: return
          LineNumberTable:
            line 3: 0
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0       9     0  this   Lreflection/generic/PrintLogChild2;

我们可以看到，字节码中printLog有两个方法，一个是： public void printLog(java.lang.String);，一个是public void printLog(java.lang.Object);其中在printLog(java.lang.Object);中又调用了 printLog(java.lang.String)方法  
我们仔细想想，其实是合理的。  
1、因为PrintLog是泛型类，编译之后会泛型擦除为Object类型，  
2、而PrintLogChild2 是继承PrintLog，并重写printLog方法，重写方法必须保证参数一致，所以要有参数为Object的方法  
3、而重载的原方法参数类型为String，所以编译期自动为该类生成参数为Object的桥接方法，并调用原有的重载方法。  
这就是桥接方法的由来。

另外，我们可以看到

public void printLog(java.lang.Object);
        flags: ACC_PUBLIC, ACC_BRIDGE, ACC_SYNTHETIC

桥接方法的标记位加上了ACC\_BRIDGE, ACC\_SYNTHETIC，表明这个方法是桥接方法，同时是编译器自动生成的。

#### 当泛型遇上反射 ####

既然我们说了桥接方法，就有必要说说桥接方法当遇到反射操作的时候可能遇到的坑。  
看下面一段代码：

@Test
    	public void testBridgeMethod(){ 
    		PrintLogChild2 child2 = new PrintLogChild2();
    		child2.getClass().getDeclaredMethods();
    	}

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzk2ODYxMw_size_16_color_FFFFFF_t_70_pic_center]  
可以看到，当反射获取方法的时候，桥接方法也会被查出来，如果我们不知道桥接方法的存在，就有可能出现bug。

#### 避免坑的方法 ####

1、通过getDeclaredMethod传入name和参数类型，可以把桥接方法过滤掉，可以参考一下：https://blog.csdn.net/weixin\_37968613/article/details/108506509

public Method getDeclaredMethod(String name, Class<?>... parameterTypes)

2、使用Method的isBridge方法，判断方法是不是桥接方法。

/** * Returns {@code true} if this method is a bridge * method; returns {@code false} otherwise. * * @return true if and only if this method is a bridge * method as defined by the Java Language Specification. * @since 1.5 */
        public boolean isBridge() { 
            return (getModifiers() & Modifier.BRIDGE) != 0;
        }

如：

@Test
    	public void testBridgeMethod(){ 
    		PrintLogChild2 child2 = new PrintLogChild2();
    		Arrays.stream(child2.getClass().getDeclaredMethods())
    				.filter(method -> !method.isBridge())
    				.collect(Collectors.toList());
    	}

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzk2ODYxMw_size_16_color_FFFFFF_t_70_pic_center]: /images/20210518/15f2f48fcc3d4a49a0c2fcac19d4a41c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzk2ODYxMw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20210518/32a910d1b8f447d1a1f8ebbcb05d95f9.png