LambdaQueryWrapper的实现原理
mybatis-plus的LambdaQueryWrapper的lambda来组合查询字段的功能十分好用，但是它是如何实现的呢?
通过查看mybatis的源码发现它的功能主要是四个类来实现的。
我将其copy下来分析下。
SFunction 类
@FunctionalInterface
public interface SFunction<T, R> extends Function<T, R>, Serializable {
}
我们知道每个lambda表达式都有一个对应的接口， 而mybatis-plus就是使用上面的接口来声明lambda表达式的。 可以看到它实现了Serializable接口。
LambdaUtils
public final class LambdaUtils {
.....................
public static <T> EntityTableDefine.ColumnProp getColumnProp(SFunction<T, ?> func) {
SerializedLambda resolve = LambdaUtils.resolve(func);
return getColumnProp(resolve);
}
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;
});
}
...................
}
把其中最重要的两个方法贴出来，resolve 方法才是重点。 可以看到其中调用了SerializedLambda.resolve(func);方法。
SerializedLambda
@SuppressWarnings("unused")
public class SerializedLambda implements Serializable {
........
public static SerializedLambda resolve(SFunction<?, ?> lambda) {
if (!lambda.getClass().isSynthetic()) {
throw ExceptionUtils.mpe("该方法仅能传入 lambda 表达式产生的合成类");
}
try (ObjectInputStream objIn = new ObjectInputStream(new ByteArrayInputStream(SerializationUtils.serialize(lambda))) {
@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);
}
}
..............
}
SerializationUtils.serialize(lambda)方法就是正常的序列化类， 无什么特别的.
resolveClass方法才是重点方法， 这个方法的目的是获取反序列化后的类的类型，上面是被重新了。 参数ObjectStreamClass中是包含了反序列化后的类型，在jdk8之后lambda被反序列化后类型都是java.lang.invoke.SerializedLambda.class，这里重写进行了替换成自己定义的SerializedLambda类型。
两个类型的代码是一样的（没发现差异）， mybatis-plus之所以复制这个类是为了方便控制吧(猜测)。 SerializedLambda类中就包含了lambda的方法的名称，而get/set方法的名称自然就能对应到具体的字段了。
至于为何可以替换的原因我在这个方法上面注释了。
思考
序列化和反序列化是比价消耗性能的， 所以mybatis-plus使用了static的Map和WeakReference来缓存了序列化后的SerializedLambda对象。 至于为何使用WeakReference的方式来做缓存， 可以参考下ThreadLocal的实现原理
其实mybatis-plus的实现方式显得繁琐了。其实没有必要去复制SerializedLambda类代码，也没有必要去真的序列化和反序列。
对象序列化中的 writeReplace 和 readResolve
writeReplace：在将对象序列化之前，如果对象的类或父类中存在writeReplace方法，则使用writeReplace的返回值作为真实被序列化的对象；writeReplace在writeObject之前执行；readResolve：在将对象反序列化之后，ObjectInputStream.readObject返回之前，如果从对象流中反序列化得到的对象所属类或父类中存在readResolve方法，则使用readResolve的返回值作为ObjectInputStream.readObject的返回值；readResolve在readObject之后执行；
函数式接口如果继承了Serializable，使用Lambda表达式来传递函数式接口时，编译器会为Lambda表达式生成一个writeReplace方法，这个生成的writeReplace方法会返回java.lang.invoke.SerializedLambda；可以从反射Lambda表达式的Class证明writeReplace的存在（具体操作与截图在后面）；所以在序列化Lambda表达式时，实际上写入对象流中的是一个SerializedLambda对象，且这个对象包含了Lambda表达式的一些描述信息；
SerializedLambda类中有readResolve方法，这个readResolve方法中通过反射调用了Lambda表达式所在外部类中的** deserializeLambda deserializeLambda deserializeLambda**方法，这个方法是编译器自动生成的，可以通过反编译.class字节码证明（具体操作与截图在后面）； deserializeLambda deserializeLambda deserializeLambda方法内部解析SerializedLambda，并调用LambdaMetafactory.altMetafactory或LambdaMetafactory.metafactory方法（引导方法）得到一个调用点（CallSite），CallSite会被动态指定为Lambda表达式代表的函数式接口类型，并作为Lambda表达式返回；所以在从对象流反序列化得到SerializedLambda对象之后，又被转换成原来的Lambda表达式，通过ObjectInputStream.readObject返回；
从上面的黑体中就能够知道， 在序列化lambda的时候实际上是序列化了SerializedLambda对象，所以反序列化后就能获取SerializedLambda对象了。 实际上序列化的对象是通过writeReplace方法产生的，那么我们要获取SerializedLambda对象没必要真的序列化和反序列化一遍。 反射调用writeReplace方法就可以了。
具体示例如下
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 {
// 直接调用writeReplace
Method writeReplace = func.getClass().getDeclaredMethod("writeReplace");
writeReplace.setAccessible(true);
//反射调用
Object sl = writeReplace.invoke(func);
java.lang.invoke.SerializedLambda serializedLambda = (java.lang.invoke.SerializedLambda) sl;
return serializedLambda;
}
}
输出结果： 可以看到获取到了方法名和类名。 知道方法名再去掉get/set前缀就是字段名称了
方法名：getFieldA
类名：xyz/xiezc/ioc/starter/orm/lambda/LambdaTest
serializedLambda：{"implMethodName":"getFieldA","implClass":"xyz/xiezc/ioc/starter/orm/lambda/LambdaTest","functionalInterfaceClass":"xyz/xiezc/ioc/starter/orm/lambda/SFunction","capturingClass":"xyz/xiezc/ioc/starter/orm/lambda/LambdaTest","instantiatedMethodType":"(Lxyz/xiezc/ioc/starter/orm/lambda/LambdaTest;)Ljava/lang/String;","functionalInterfaceMethodSignature":"(Ljava/lang/Object;)Ljava/lang/Object;","implMethodSignature":"()Ljava/lang/String;","functionalInterfaceMethodName":"apply","implMethodKind":5}
以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程网。
