Class

  1. @FunctionalInterface
  2. public interface CacheFunction extends Serializable {
  4.     /**
  5.      * 这里只接收无参方法
  6.      *
  7.      * @return
  8.      */
  9.     Object apply();
  11.     /**
  12.      * 这个方法返回的SerializedLambda是重点
  13.      *
  14.      * @return
  15.      * @throws Exception
  16.      */
  17.     default SerializedLambda getSerializedLambda() throws Exception {
  18.         SerializedLambda obj = CacheCommonUtils.cacheFunctionClassMap.get(this.getClass().getName());
  19.         if (null == obj) {
  20.             //writeReplace改了好像会报异常
  21.             Method write = this.getClass().getDeclaredMethod("writeReplace");
  22.             write.setAccessible(true);
  23.             obj = (SerializedLambda) write.invoke(this);
  24.             CacheCommonUtils.cacheFunctionClassMap.put(this.getClass().getName(), obj);
  25.         }
  26.         return obj;
  27.     }
  29.     /**
  30.      * getImplClass
  31.      *
  32.      * @return
  33.      */
  34.     default String getImplClass() {
  35.         try {
  36.             return getSerializedLambda().getImplClass();
  37.         } catch (Exception e) {
  38.             return null;
  39.         }
  40.     }
  42.     /**
  43.      * getImplMethodName
  44.      *
  45.      * @return
  46.      */
  47.     default String getImplMethodName() {
  48.         try {
  49.             return getSerializedLambda().getImplMethodName();
  50.         } catch (Exception e) {
  51.             return null;
  52.         }
  53.     }
  55.     /**
  56.      * 获取方法名称
  57.      *
  58.      * @return
  59.      */
  60.     default String fnToFnName() {
  61.         try {
  62.             String[] split = getSerializedLambda().getImplMethodName().split("\\$", 3);
  63.             return split[1];
  64.         } catch (Exception e) {
  65.         }
  66.         return "";
  67.     }
  69.     /**
  70.      * 获取方法参数，反射已缓存，每次拿到的参数都是第一次调用时的
  71.      *
  72.      * @return
  73.      */
  74.     @Deprecated
  75.     default List<Object> getFuncFields() {
  76.         try {
  77.             SerializedLambda serializedLambda = getSerializedLambda();
  78.             List<Object> list = new ArrayList<>(serializedLambda.getCapturedArgCount());
  79.             for (int i = 0; i < serializedLambda.getCapturedArgCount(); i++) {
  80.                 if (!serializedLambda.getCapturedArg(i).toString().startsWith("com.")) {
  81.                     list.add(serializedLambda.getCapturedArg(i));
  82.                 }
  83.             }
  84.             return list;
  85.         } catch (Exception e) {
  86.         }
  87.         return new ArrayList<>();
  88.     }
  89. }

介绍

在Lcache中，对cache的封装都是通过CacheFunction进行传递执行，大量的场景需要获取方法名称，单纯的反射即可获取；但是性能太低，因此通过Map将反射对象进行缓存，大大提高性能
Map cacheFunctionClassMap = new ConcurrentHashMap<>();

使用

  1. String commands = function.fnToFnName();
  2. //通过数据结构Util还可获取方法的数据结构等信息
  3. String dataStructure = CommandsDataTypeUtil.getCommandsDataType(commands).name()