LambdaQueryWrapper的实现原理
mybatis-plus的LambdaQueryWrapper的lambda来组合查询字段的功能十分好用,但是它是如何实现的呢?
通过查看mybatis的源码发现它的功能主要是四个类来实现的。
我将其copy下来分析下。
SFunction 类
/** * 支持序列化的 Function * * @author miemie * @since 2018-05-12 */ @FunctionalInterface public interface SFunctionextends Function , Serializable { }
我们知道每个lambda表达式都有一个对应的接口, 而mybatis-plus就是使用上面的接口来声明lambda表达式的。 可以看到它实现了Serializable接口。
LambdaUtils
/** * Lambda 解析工具类 * * @author HCL, MieMie * @since 2018-05-10 */ public final class LambdaUtils { ..................... /** * 获取对应的表字段与对象的属性关系对象 * * @param func * @param* @return */ public static EntityTableDefine.ColumnProp getColumnProp(SFunction func) { SerializedLambda resolve = LambdaUtils.resolve(func); return getColumnProp(resolve); } /** * 解析 lambda 表达式, 该方法只是调用了 {@link SerializedLambda#resolve(SFunction)} 中的方法,在此基础上加了缓存。 * 该缓存可能会在任意不定的时间被清除 * * @param func 需要解析的 lambda 对象 * @param 类型,被调用的 Function 对象的目标类型 * @return 返回解析后的结果 * @see SerializedLambda#resolve(SFunction) */ public static SerializedLambda resolve(SFunction 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
/** * 这个类是从 {@link java.lang.invoke.SerializedLambda} 里面 copy 过来的, * 字段信息完全一样 *负责将一个支持序列的 Function 序列化为 SerializedLambda
* * @author HCL * @since 2018/05/10 */ @SuppressWarnings("unused") public class SerializedLambda implements Serializable { ........ /** * 通过反序列化转换 lambda 表达式,该方法只能序列化 lambda 表达式,不能序列化接口实现或者正常非 lambda 写法的对象 * * @param lambda lambda对象 * @return 返回解析后的 SerializedLambda */ public static SerializedLambda resolve(SFunction lambda) { if (!lambda.getClass().isSynthetic()) { throw ExceptionUtils.mpe("该方法仅能传入 lambda 表达式产生的合成类"); } try (ObjectInputStream objIn = new ObjectInputStream(new ByteArrayInputStream(SerializationUtils.serialize(lambda))) { /** * 实现反序列化的类型的替换, 使用我们自定义的类型来替换java.lang.invoke.SerializedLambda类。 * 为何可以替换成功, 因为反序列化的时候使用的是反射的方式赋值的, 只要两个类的方法名称或者字段名一样,反射调用是没有问题的。 * @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); } } .............. }
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 staticjava.lang.invoke.SerializedLambda doSFunction(SFunction 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}
以上为个人经验,希望能给大家一个参考,也希望大家多多支持脚本之家。