使用Lambda 序列化工具获得属性名 来替换动态代理,提升性能

Author: xuejike0

demo/src/main/resources/application.yml

@@ -1,9 +1,12 @@
 spring:
   datasource:
     name: jk-fast-start
-    url: jdbc:mysql://192.168.1.156:3306/test?useUnicode=true
+    url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true
     username: root
     driver-class-name: com.mysql.jdbc.Driver
-    password: 123456
+    password: root
+
   jpa:
-    show-sql: true
+    show-sql: true
+    hibernate:
+      ddl-auto: update

jpa-lambda-core/src/main/java/com/github/xuejike/query/jpa/lambda/JpaLambdaQuery.java

@@ -3,6 +3,7 @@
 import com.github.xuejike.query.jpa.lambda.core.*;
 import com.github.xuejike.query.jpa.lambda.proxy.GeterSeterMethodInterceptor;
 import com.github.xuejike.query.jpa.lambda.proxy.Proxy;
+import com.github.xuejike.query.jpa.lambda.tool.LambdaTool;
 import org.hibernate.Session;
 import org.hibernate.criterion.Criterion;
 import org.hibernate.criterion.MatchMode;
@@ -37,17 +38,18 @@ public JpaLambdaQuery(Class<T> entityCls,Session session) {
     }
 
     protected String getFieldName(FieldFunction<T, ?> fieldFun){
-        fieldFun.apply(proxy);
-        return proxyInterceptor.getLastPropertyName();
+
+        String name = LambdaTool.getName(fieldFun);
+        return name;
     }
+
     protected String[] getFieldNames(FieldFunction<T, ?> ...fieldFun){
         return Optional.ofNullable(fieldFun)
                 .filter(f->f.length>0)
                 .map(f->{
                     String[] fieldNames = new String[fieldFun.length];
                     for (int i = 0; i < fieldFun.length; i++) {
-                        fieldFun[i].apply(proxy);
-                        fieldNames[i] = proxyInterceptor.getLastPropertyName();
+                        fieldNames[i] = getFieldName(fieldFun[i]);
                     }
                     return fieldNames;
                 }).orElse(null);

jpa-lambda-core/src/main/java/com/github/xuejike/query/jpa/lambda/core/FieldFunction.java

@@ -1,5 +1,7 @@
 package com.github.xuejike.query.jpa.lambda.core;
 
-public interface FieldFunction<T,R> {
+import java.io.Serializable;
+
+public interface FieldFunction<T,R> extends Serializable {
     R apply(T entity);
 }

jpa-lambda-core/src/main/java/com/github/xuejike/query/jpa/lambda/exception/JpaLambdaException.java

@@ -0,0 +1,11 @@
+package com.github.xuejike.query.jpa.lambda.exception;
+
+public class JpaLambdaException extends RuntimeException {
+    public JpaLambdaException(String message) {
+        super(message);
+    }
+
+    public JpaLambdaException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

jpa-lambda-core/src/main/java/com/github/xuejike/query/jpa/lambda/tool/ClassUtils.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2011-2020, baomidou (jobob@qq.com).
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.github.xuejike.query.jpa.lambda.tool;
+
+import com.github.xuejike.query.jpa.lambda.exception.JpaLambdaException;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * <p>
+ * ClassUtils
+ * </p>
+ *
+ */
+public final class ClassUtils {
+
+
+    private ClassUtils() {
+    }
+
+    /**
+     * <p>
+     * 请仅在确定类存在的情况下调用该方法
+     * </p>
+     *
+     * @param name 类名称
+     * @return 返回转换后的 Class
+     */
+    public static Class<?> toClassConfident(String name) {
+        try {
+            return Class.forName(name);
+        } catch (ClassNotFoundException e) {
+            throw new JpaLambdaException("找不到指定的class！请仅在明确确定会有 class 的时候，调用该方法", e);
+        }
+    }
+
+
+
+}

jpa-lambda-core/src/main/java/com/github/xuejike/query/jpa/lambda/tool/LambdaTool.java

@@ -0,0 +1,45 @@
+package com.github.xuejike.query.jpa.lambda.tool;
+
+import com.github.xuejike.query.jpa.lambda.core.FieldFunction;
+import com.github.xuejike.query.jpa.lambda.exception.JpaLambdaException;
+
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class LambdaTool {
+    public static String methodToProperty(String name) {
+        if (name.startsWith("is")) {
+            name = name.substring(2);
+        } else if (name.startsWith("get") || name.startsWith("set")) {
+            name = name.substring(3);
+        } else {
+            throw new JpaLambdaException("Error parsing property name '" + name + "'.  Didn't start with 'is', 'get' or 'set'.");
+        }
+
+        if (name.length() == 1 || (name.length() > 1 && !Character.isUpperCase(name.charAt(1)))) {
+            name = name.substring(0, 1).toLowerCase(Locale.ENGLISH) + name.substring(1);
+        }
+
+        return name;
+    }
+
+    protected static Map<Class, WeakReference<String>> cache = new ConcurrentHashMap<>();
+    public static<T> String getName(FieldFunction<T,?> fieldFun){
+        Class<? extends FieldFunction> cls = fieldFun.getClass();
+        return Optional.ofNullable(cache.get(cls))
+                .map(WeakReference::get)
+                .orElseGet(()->{
+                    SerializedLambda lambda = SerializedLambda.resolve(fieldFun);
+                    String methodName = lambda.getImplMethodName();
+                    String property = methodToProperty(methodName);
+                    WeakReference<String> wr = new WeakReference<>(property);
+                    cache.put(cls,wr);
+                    return property;
+                });
+
+    }
+}

jpa-lambda-core/src/main/java/com/github/xuejike/query/jpa/lambda/tool/SerializationUtils.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2011-2020, baomidou (jobob@qq.com).
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.github.xuejike.query.jpa.lambda.tool;
+
+import java.io.*;
+
+
+/**
+ * <p>copy from org.springframework.util.SerializationUtils</p>
+ *
+ * @since 1.0
+ */
+public class SerializationUtils {
+
+    /**
+     * Deep clone an {@code Object} using serialization.
+     * <p>This is many times slower than writing clone methods by hand
+     * on all objects in your object graph. However, for complex object
+     * graphs, or for those that don't support deep cloning this can
+     * be a simple alternative implementation. Of course all the objects
+     * must be {@code Serializable}.</p>
+     *
+     * @param <T>    the type of the object involved
+     * @param object the {@code Serializable} object to clone
+     * @return the cloned object
+     */
+    @SuppressWarnings("unchecked")
+    public static <T extends Serializable> T clone(final T object) {
+        if (object == null) {
+            return null;
+        }
+        final byte[] objectData = serialize(object);
+        return (T) deserialize(objectData);
+    }
+
+    /**
+     * Serialize the given object to a byte array.
+     * @param object the object to serialize
+     * @return an array of bytes representing the object in a portable fashion
+     */
+    public static byte[] serialize(Object object) {
+        if (object == null) {
+            return null;
+        }
+        ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
+        try {
+            ObjectOutputStream oos = new ObjectOutputStream(baos);
+            oos.writeObject(object);
+            oos.flush();
+        } catch (IOException ex) {
+            throw new IllegalArgumentException("Failed to serialize object of type: " + object.getClass(), ex);
+        }
+        return baos.toByteArray();
+    }
+
+    /**
+     * Deserialize the byte array into an object.
+     *
+     * @param bytes a serialized object
+     * @return the result of deserializing the bytes
+     */
+    public static Object deserialize(byte[] bytes) {
+        if (bytes == null) {
+            return null;
+        }
+        try {
+            ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
+            return ois.readObject();
+        } catch (IOException ex) {
+            throw new IllegalArgumentException("Failed to deserialize object", ex);
+        } catch (ClassNotFoundException ex) {
+            throw new IllegalStateException("Failed to deserialize object type", ex);
+        }
+    }
+}

jpa-lambda-core/src/main/java/com/github/xuejike/query/jpa/lambda/tool/SerializedLambda.java

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2011-2020, baomidou (jobob@qq.com).
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.github.xuejike.query.jpa.lambda.tool;
+
+
+import com.github.xuejike.query.jpa.lambda.core.FieldFunction;
+import com.github.xuejike.query.jpa.lambda.exception.JpaLambdaException;
+
+import java.io.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 这个类是从 {@link java.lang.invoke.SerializedLambda} 里面 copy 过来的
+ * <p>负责将一个支持序列的 Function 序列化为 SerializedLambda</p>
+ *
+ */
+@SuppressWarnings("unused")
+public class SerializedLambda implements Serializable {
+
+    private static final long serialVersionUID = 8025925345765570181L;
+
+    private Class<?> capturingClass;
+    private String functionalInterfaceClass;
+    private String functionalInterfaceMethodName;
+    private String functionalInterfaceMethodSignature;
+    private String implClass;
+    private String implMethodName;
+    private String implMethodSignature;
+    private int implMethodKind;
+    private String instantiatedMethodType;
+    private Object[] capturedArgs;
+
+    /**
+     * 通过反序列化转换 lambda 表达式，该方法只能序列化 lambda 表达式，不能序列化接口实现或者正常非 lambda 写法的对象
+     *
+     * @param lambda lambda对象
+     * @return 返回解析后的 SerializedLambda
+     */
+    public static SerializedLambda resolve(FieldFunction<?, ?> lambda) {
+        if (!lambda.getClass().isSynthetic()) {
+            throw new JpaLambdaException("该方法仅能传入 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;
+            }
+        }) {
+            return (SerializedLambda) objIn.readObject();
+        } catch (ClassNotFoundException | IOException e) {
+            throw new JpaLambdaException("This is impossible to happen", e);
+        }
+    }
+
+    /**
+     * 获取接口 class
+     *
+     * @return 返回 class 名称
+     */
+    public String getFunctionalInterfaceClassName() {
+        return normalName(functionalInterfaceClass);
+    }
+
+    /**
+     * 获取实现的 class
+     *
+     * @return 实现类
+     */
+    public Class<?> getImplClass() {
+        return ClassUtils.toClassConfident(getImplClassName());
+    }
+
+    /**
+     * 获取 class 的名称
+     *
+     * @return 类名
+     */
+    public String getImplClassName() {
+        return normalName(implClass);
+    }
+
+    /**
+     * 获取实现者的方法名称
+     *
+     * @return 方法名称
+     */
+    public String getImplMethodName() {
+        return implMethodName;
+    }
+
+    /**
+     * 正常化类名称，将类名称中的 / 替换为 .
+     *
+     * @param name 名称
+     * @return 正常的类名
+     */
+    private String normalName(String name) {
+        return name.replace('/', '.');
+    }
+
+    private static final Pattern INSTANTIATED_METHOD_TYPE = Pattern.compile("\\(L(?<instantiatedMethodType>[\\S&&[^;)]]+);\\)L[\\S]+;");
+
+    public Class getInstantiatedMethodType() {
+        Matcher matcher = INSTANTIATED_METHOD_TYPE.matcher(instantiatedMethodType);
+        if (matcher.find()) {
+            return ClassUtils.toClassConfident(normalName(matcher.group("instantiatedMethodType")));
+        }
+        throw new JpaLambdaException(String.format("无法从 %s 解析调用实例。。。", instantiatedMethodType));
+    }
+
+    /**
+     * @return 字符串形式
+     */
+    @Override
+    public String toString() {
+        return String.format("%s -> %s::%s", getFunctionalInterfaceClassName(), getImplClass().getSimpleName(),
+            implMethodName);
+    }
+
+}