前言

在我們開發(fā)過程中常常有一個需求，就是要知道實體類中Getter方法對應的屬性名稱（Field Name），例如實體類屬性到數(shù)據(jù)庫字段的映射，我們常常是硬編碼指定 屬性名，這種硬編碼有兩個缺點。

1、編碼效率低：因為要硬編碼寫屬性名，很可能寫錯，需要非常小心，時間浪費在了不必要的檢查上。

2、容易讓開發(fā)人員踩坑：例如有一天發(fā)現(xiàn)實體類中Field Name定義的不夠明確，希望換一個Field Name，那么代碼所有硬編碼的Field Name都要跟著變更，對于未并更的地方，是無法在編譯期發(fā)現(xiàn)的。只要有未變更的地方都可能導致bug的出現(xiàn)。

而使用了方法引用后，如果Field Name變更及其對應的Getter/Setter方法變更，編譯器便可以實時的幫助我們檢查變更的代碼，在編譯器給出錯誤信息。

那么如何通過方法引用獲取Getter方法對應的Field Name呢？

Java8中給我們提供了實現(xiàn)方式，首先要做的就是定義一個可序列化的函數(shù)式接口(實現(xiàn)Serializable)，實現(xiàn)如下：

/**
 * Created by bruce on 2020/4/10 14:16
 */
@FunctionalInterface
public interface SerializableFunction<T, R> extends Function<T, R>, Serializable {
 
}

而在使用時,我們需要傳遞Getter方法引用

 //方法引用
SerializableFunction<People, String> getName1 = People::getName;
Field field = ReflectionUtil.getField(getName1);

下面看具體怎么解析這個SerializableFunction，完整實現(xiàn)如下ReflectionUtil

public class ReflectionUtil {
 
  private static Map<SerializableFunction<?, ?>, Field> cache = new ConcurrentHashMap<>();
 
  public static <T, R> String getFieldName(SerializableFunction<T, R> function) {
    Field field = ReflectionUtil.getField(function);
    return field.getName();
  }
  public static Field getField(SerializableFunction<?, ?> function) {
    return cache.computeIfAbsent(function, ReflectionUtil::findField);
  }
  public static Field findField(SerializableFunction<?, ?> function) {
    Field field = null;
    String fieldName = null;
    try {
      // 第1步 獲取SerializedLambda
      Method method = function.getClass().getDeclaredMethod("writeReplace");
      method.setAccessible(Boolean.TRUE);
      SerializedLambda serializedLambda = (SerializedLambda) method.invoke(function);
      // 第2步 implMethodName 即為Field對應的Getter方法名
      String implMethodName = serializedLambda.getImplMethodName();
      if (implMethodName.startsWith("get") && implMethodName.length() > 3) {
        fieldName = Introspector.decapitalize(implMethodName.substring(3));
 
      } else if (implMethodName.startsWith("is") && implMethodName.length() > 2) {
        fieldName = Introspector.decapitalize(implMethodName.substring(2));
      } else if (implMethodName.startsWith("lambda$")) {
        throw new IllegalArgumentException("SerializableFunction不能傳遞lambda表達式,只能使用方法引用");
        
      } else {
        throw new IllegalArgumentException(implMethodName + "不是Getter方法引用");
      }
      // 第3步 獲取的Class是字符串，并且包名是“/”分割，需要替換成“.”，才能獲取到對應的Class對象
      String declaredClass = serializedLambda.getImplClass().replace("/", ".");
      Class<?> aClass = Class.forName(declaredClass, false, ClassUtils.getDefaultClassLoader());
 
      // 第4步 Spring 中的反射工具類獲取Class中定義的Field
      field = ReflectionUtils.findField(aClass, fieldName);
 
    } catch (Exception e) {
      e.printStackTrace();
    }
    // 第5步 如果沒有找到對應的字段應該拋出異常
    if (field != null) {
      return field;
    }
    throw new NoSuchFieldError(fieldName);
  }
}

該類中主要有如下三個方法

• String getFieldName(SerializableFunction<T, R> function) 獲取Field的字符串name
• Field getField(SerializableFunction<?, ?> function)從緩存中查詢方法引用對應的Field,如果沒有則通過findField(SerializableFunction<?, ?> function)方法反射獲取
• Field findField(SerializableFunction<?, ?> function) 反射獲取方法應用對應的Field

實現(xiàn)原理

1、首先我們看最后一個方法Field findField(SerializableFunction<?, ?> function)，該方法中第一步是通過SerializableFunction對象獲取Class，即傳遞的方法引用，然后反射獲取writeReplace()方法,并調(diào)用該方法獲取導SerializedLambda對象。

2、SerializedLambda是Java8中提供，主要就是用于封裝方法引用所對應的信息，主要的就是方法名、定義方法的類名、創(chuàng)建方法引用所在類。

3、拿到這些信息后，便可以通過反射獲取對應的Field。

4、而在方法Field getField(SerializableFunction<?, ?> function)中對獲取到的Field進行緩存，避免每次都反射獲取，造成資源浪費。

除此之外似乎還有一些值得思考的問題

writeReplace()方法是哪來的呢?

首先簡單了解一下java.io.Serializable接口，該接口很常見，我們在持久化一個對象或者在RPC框架之間通信使用JDK序列化時都會讓傳輸?shù)膶嶓w類實現(xiàn)該接口，該接口是一個標記接口沒有定義任何方法，但是該接口文檔中有這么一段描述：

Serializable classes that need to designate an alternative object to be used when writing an object to the stream should implement this special method with the exact signature:
   ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
  
This writeReplace method is invoked by serialization if the method exists and it would be accessible from a method defined within the class of the object being serialized. Thus, the method can have private, protected and package-private access. Subclass access to this method follows java accessibility rules.

概要意思就是說，如果想在序列化時改變序列化的對象，可以通過在實體類中定義任意訪問權限的Object writeReplace()來改變默認序列化的對象。

那么我們的定義的SerializableFunction中并沒有定義writeReplace()方法，這個方法是哪來的呢？
代碼中SerializableFunction,Function只是一個接口，但是其在最后必定也是一個實現(xiàn)類的實例對象，而方法引用其實是在運行時動態(tài)創(chuàng)建的，當代碼執(zhí)行到方法引用時,如People::getName，最后會經(jīng)過
java.lang.invoke.LambdaMetafactory
java.lang.invoke.InnerClassLambdaMetafactory
去動態(tài)的創(chuàng)建實現(xiàn)類。而在動態(tài)創(chuàng)建實現(xiàn)類時則會判斷函數(shù)式接口是否實現(xiàn)了Serializable，如果實現(xiàn)了，則添加writeReplace()

值得注意的是，代碼中多次編寫的同一個方法引用，他們創(chuàng)建的是不同F(xiàn)unction實現(xiàn)類，即他們的Function實例對象也并不是同一個
我們可以通過如下屬性配置將 動態(tài)生成的Class保存到 磁盤上

java8中可以通過硬編碼

 System.setProperty("jdk.internal.lambda.dumpProxyClasses", ".");

jdk11 中只能使用jvm參數(shù)指定,硬編碼無效,原因是模塊化導致的

-Djdk.internal.lambda.dumpProxyClasses=.

示例代碼如下:

動態(tài)生成的Class如下:

一個方法引用創(chuàng)建一個實現(xiàn)類，他們是不同的對象，那么ReflectionUtil中將SerializableFunction最為緩存key還有意義嗎？

答案是肯定有意義的?。?！因為同一方法中的定義的Function只會動態(tài)的創(chuàng)建一次實現(xiàn)類并只實例化一次，當該方法被多次調(diào)用時即可走緩存中查詢該方法引用對應的Field

這里的緩存Key應該選用SerializableFunction#Class還是SerializableFunction實例對象好呢?

看到有些實現(xiàn)使用SerializableFunction的Class作為緩存key，代碼如下：

public static Field getField(SerializableFunction<?, ?> function) {
   //使用SerializableFunction的Class作為緩存key，導致每次都調(diào)用function.getClass()
   return cache.computeIfAbsent(function.getClass(), ReflectionUtil::findField);
}

但是個人建議采用SerializableFunction對象，因為無論方法被調(diào)用多少次，方法代碼塊內(nèi)的方法引用對象始終是同一個，如果采用其Class做為緩存key，每次查詢緩存時都需要調(diào)用native方法function.getClass()獲取其Class，也是一種資源損耗。

總結(jié)：Java如何通過方法引用獲取屬性名實現(xiàn)及思考至此結(jié)束。直接使用ReflectionUtil即可

到此這篇關于Java8中如何通過方法引用獲取屬性名的文章就介紹到這了,更多相關Java8通過方法引用獲取屬性名內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論