/**
 * 支持序列化的 Function
 *
 * @author miemie
 * @since 2018-05-12
 */
@FunctionalInterface
public interface SFunction<T, R> extends Function<T, R>, Serializable {
}

/**
 * Lambda 解析工具類
 *
 * @author HCL, MieMie
 * @since 2018-05-10
 */
public final class LambdaUtils {
.....................
 /**
     * 獲取對應的表字段與對象的屬性關系對象
     *
     * @param func
     * @param <T>
     * @return
     */
    public static <T> EntityTableDefine.ColumnProp getColumnProp(SFunction<T, ?> func) {
        SerializedLambda resolve = LambdaUtils.resolve(func);
        return getColumnProp(resolve);
    }
  /**
     * 解析 lambda 表達式, 該方法只是調(diào)用了 {@link SerializedLambda#resolve(SFunction)} 中的方法，在此基礎上加了緩存。
     * 該緩存可能會在任意不定的時間被清除
     *
     * @param func 需要解析的 lambda 對象
     * @param <T>  類型，被調(diào)用的 Function 對象的目標類型
     * @return 返回解析后的結(jié)果
     * @see SerializedLambda#resolve(SFunction)
     */
    public static <T> SerializedLambda resolve(SFunction<T, ?> func) {
        Class<?> clazz = func.getClass();
        return Optional.ofNullable(FUNC_CACHE.get(clazz))
                .map(WeakReference::get)
                .orElseGet(() -> {
                    SerializedLambda lambda = SerializedLambda.resolve(func);
                    FUNC_CACHE.put(clazz, new WeakReference<>(lambda));
                    return lambda;
                });
    }
  
  
  ................... 
}

/**
 * 這個類是從 {@link java.lang.invoke.SerializedLambda} 里面 copy 過來的，
 * 字段信息完全一樣
 * <p>負責將一個支持序列的 Function 序列化為 SerializedLambda</p>
 *
 * @author HCL
 * @since 2018/05/10
 */
@SuppressWarnings("unused")
public class SerializedLambda implements Serializable {
  ........
    
/**
     * 通過反序列化轉(zhuǎn)換 lambda 表達式，該方法只能序列化 lambda 表達式，不能序列化接口實現(xiàn)或者正常非 lambda 寫法的對象
     *
     * @param lambda lambda對象
     * @return 返回解析后的 SerializedLambda
     */
    public static SerializedLambda resolve(SFunction<?, ?> lambda) {
        if (!lambda.getClass().isSynthetic()) {
            throw ExceptionUtils.mpe("該方法僅能傳入 lambda 表達式產(chǎn)生的合成類");
        }
        try (ObjectInputStream objIn = new ObjectInputStream(new ByteArrayInputStream(SerializationUtils.serialize(lambda))) {
            /**
             * 實現(xiàn)反序列化的類型的替換， 使用我們自定義的類型來替換java.lang.invoke.SerializedLambda類。
             * 為何可以替換成功， 因為反序列化的時候使用的是反射的方式賦值的， 只要兩個類的方法名稱或者字段名一樣，反射調(diào)用是沒有問題的。
             * @param objectStreamClass
             * @return
             * @throws IOException
             * @throws ClassNotFoundException
             */
            @Override
            protected Class<?> resolveClass(ObjectStreamClass objectStreamClass) throws IOException, ClassNotFoundException {
                Class<?> clazz = super.resolveClass(objectStreamClass);
                return clazz == java.lang.invoke.SerializedLambda.class ? SerializedLambda.class : clazz;
            }
        }) {
            //因為前面的替換，這里獲取的就是我們自己定義的SerializedLambda類
            return (SerializedLambda) objIn.readObject();
        } catch (ClassNotFoundException | IOException e) {
            throw ExceptionUtils.mpe("This is impossible to happen", e);
        }
    }
  
  .............. 
    
 }

package xyz.xiezc.ioc.starter.orm.lambda;
import cn.hutool.json.JSONUtil;
import lombok.Data;
import java.lang.invoke.SerializedLambda;
import java.lang.reflect.Method;
@Data
public class LambdaTest {
    private String fieldA;
    public static void main(String[] args) throws Exception {
        SerializedLambda serializedLambda = doSFunction(LambdaTest::getFieldA);
        System.out.println("方法名：" + serializedLambda.getImplMethodName());
        System.out.println("類名：" + serializedLambda.getImplClass());
        System.out.println("serializedLambda：" + JSONUtil.toJsonStr(serializedLambda));
    }
    private static <T, R> java.lang.invoke.SerializedLambda doSFunction(SFunction<T, R> func) throws Exception {
        // 直接調(diào)用writeReplace
        Method writeReplace = func.getClass().getDeclaredMethod("writeReplace");
        writeReplace.setAccessible(true);
      	//反射調(diào)用
        Object sl = writeReplace.invoke(func);
        java.lang.invoke.SerializedLambda serializedLambda = (java.lang.invoke.SerializedLambda) sl;
        return serializedLambda;
    }
}