import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
@Override
public ObjectInputFilter.Status checkInput(FilterInfo filter) {
    count++;
    if (filter.serialClass() != null) {
        if (filter.serialClass().getName().contains("$$Lambda$")) {
            // TBD: proper identification of serialized Lambdas?
            // Fold the serialized Lambda into the SerializedLambda type
            classes.add(SerializedLambda.class);
        } else if (Proxy.isProxyClass(filter.serialClass())) {
            classes.add(Proxy.class);
        } else {
            classes.add(filter.serialClass());
        }

    }
    this.maxArray = Math.max(this.maxArray, filter.arrayLength());
    this.maxRefs = Math.max(this.maxRefs, filter.references());
    this.maxDepth = Math.max(this.maxDepth, filter.depth());
    this.maxBytes = Math.max(this.maxBytes, filter.streamBytes());
    return ObjectInputFilter.Status.UNDECIDED;
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
@Override
public ObjectInputFilter.Status checkInput(FilterInfo filter) {
    Class<?> serialClass = filter.serialClass();
    System.out.printf("     checkInput: class: %s, arrayLen: %d, refs: %d, depth: %d, bytes; %d%n",
            serialClass, filter.arrayLength(), filter.references(),
            filter.depth(), filter.streamBytes());
    count++;
    if (serialClass != null) {
        if (serialClass.getName().contains("$$Lambda$")) {
            // TBD: proper identification of serialized Lambdas?
            // Fold the serialized Lambda into the SerializedLambda type
            classes.add(SerializedLambda.class);
        } else if (Proxy.isProxyClass(serialClass)) {
            classes.add(Proxy.class);
        } else {
            classes.add(serialClass);
        }

    }
    this.maxArray = Math.max(this.maxArray, filter.arrayLength());
    this.maxRefs = Math.max(this.maxRefs, filter.references());
    this.maxDepth = Math.max(this.maxDepth, filter.depth());
    this.maxBytes = Math.max(this.maxBytes, filter.streamBytes());
    return ObjectInputFilter.Status.UNDECIDED;
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
private SerializedValue createLambdaObject(Type type, Object object) {
	SerializedValue serializedObject = serialized.get(object);
	if (serializedObject == null) {
		SerializedLambda serializedLambda = Lambdas.serializeLambda(object);
		try {
			Class<?> functionalInterfaceType = classFrom(serializedLambda.getFunctionalInterfaceClass());
			Serializer serializer = fetchSerializer(serializedLambda.getClass());
			serializedObject = serializer.generate(type, functionalInterfaceType);
			serialized.put(object, serializedObject);
			if (serializedObject instanceof SerializedReferenceType) {
				((SerializedReferenceType) serializedObject).setId(identityHashCode(object));
			}
			serializer.populate(serializedObject, serializedLambda);
		} catch (RuntimeException e) {
			throw new SerializationException(e);
		}
	}
	return serializedObject;
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
private Serializer<?> fetchSerializer(Class<?> clazz) {
	Serializer<?> serializer = serializers.get(clazz);
	if (serializer != null) {
		return serializer;
	}
	if (clazz.isArray()) {
		serializer = new ArraySerializer(this);
	} else if (clazz.isEnum() || (clazz.getSuperclass() != null && clazz.getSuperclass().isEnum())) {
		serializer = new EnumSerializer(this);
	} else if (SerializedLambda.class == clazz) {
		serializer = new LambdaSerializer(this);
	} else {
		serializer = new GenericSerializer(this);
	}
	return serializer;
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
@Override
public void populate(SerializedLambdaObject serializedLambda, Object object) {
	if (!(object instanceof SerializedLambda)) {
		return;
	}
	SerializedLambda lambda = (SerializedLambda) object;

	serializedLambda.setSignature(new LambdaSignature()
		.withCapturingClass(lambda.getCapturingClass())
		.withInstantiatedMethodType(lambda.getInstantiatedMethodType())
		.withFunctionalInterface(
			lambda.getFunctionalInterfaceClass(), 
			lambda.getFunctionalInterfaceMethodName(),
			lambda.getFunctionalInterfaceMethodSignature())
		.withImplMethod(lambda.getImplClass(), lambda.getImplMethodKind(), lambda.getImplMethodName(), lambda.getImplMethodSignature()));
	

	List<SerializedValue> arguments = IntStream.range(0, lambda.getCapturedArgCount())
		.mapToObj(lambda::getCapturedArg)
		.map(o -> facade.serialize(o.getClass(), o))
		.collect(toList());
	serializedLambda.setCapturedArguments(arguments);
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
public void testReferencedLambdaExpression() {
    final LambdaKeeper keeper = new LambdaKeeper();
    keeper.keep((Callable<String> & Serializable)() -> "result");
    keeper.reference();

    final String expected = ""
        + "<keeper>\n"
        + "  <callable resolves-to=\"serialized-lambda\">\n"
        + "    <capturingClass>com.thoughtworks.acceptance.LambdaTest</capturingClass>\n"
        + "    <functionalInterfaceClass>java/util/concurrent/Callable</functionalInterfaceClass>\n"
        + "    <functionalInterfaceMethodName>call</functionalInterfaceMethodName>\n"
        + "    <functionalInterfaceMethodSignature>()Ljava/lang/Object;</functionalInterfaceMethodSignature>\n"
        + "    <implClass>com/thoughtworks/acceptance/LambdaTest</implClass>\n"
        + "    <implMethodName>lambda$0</implMethodName>\n"
        + "    <implMethodSignature>()Ljava/lang/String;</implMethodSignature>\n"
        + "    <implMethodKind>6</implMethodKind>\n"
        + "    <instantiatedMethodType>()Ljava/lang/String;</instantiatedMethodType>\n"
        + "    <capturedArgs/>\n"
        + "  </callable>\n"
        + "  <referenced class=\"java.util.concurrent.Callable\" reference=\"../callable\"/>\n"
        + "</keeper>";
    xstream.alias("keeper", LambdaKeeper.class);
    xstream.allowTypes(SerializedLambda.class);

    assertBothWaysNormalized(keeper, expected);
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
default SerializedLambda serialized() {
    try {
        Method replaceMethod = getClass().getDeclaredMethod("writeReplace");
        replaceMethod.setAccessible(true);
        return (SerializedLambda) replaceMethod.invoke(this);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
default Method method() {
    SerializedLambda lambda = serialized();
    Class<?> containingClass = getContainingClass();
    return Arrays.asList(containingClass.getDeclaredMethods())
            .stream()
            .filter(method -> Objects.equals(method.getName(), lambda.getImplMethodName()))
            .findFirst()
            .orElseThrow(UnableToGuessMethodException::new);
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
private static String nameOf(PropertyToMatch<?, ?> property) {
    Optional<String> propertyName = Stream.<Class<?>>iterate(property.getClass(), Class::getSuperclass)
            .flatMap(c -> Arrays.stream(c.getDeclaredMethods()))
            .filter(m -> m.getName().equals("writeReplace"))
            .map(m -> (SerializedLambda) invoke(m, property))
            .map(SerializedLambda::getImplMethodName)
            .findFirst();

    return propertyName.orElseThrow(() -> new RuntimeException("Unable to determine property name."));
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
public LambdaInfo(Object lambda, Kind kind, SerializedLambda serializedLambda, Method functionalMethod, Method implementationMethod) {
    this.lambda = lambda;
    this.kind = kind;
    this.serializedLambda = serializedLambda;
    this.functionalMethod = functionalMethod;
    this.implementationMethod = implementationMethod;
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
public static String fnToFieldName(Fn fn) {
    try {
        Method method = fn.getClass().getDeclaredMethod("writeReplace");
        method.setAccessible(Boolean.TRUE);
        SerializedLambda serializedLambda = (SerializedLambda) method.invoke(fn);
        String getter = serializedLambda.getImplMethodName();
        String fieldName = Introspector.decapitalize(getter.replace("get", ""));
        return fieldName;
    } catch (ReflectiveOperationException e) {
        throw new ReflectionOperationException(e);
    }
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
private void assertDeserializeMethod(Class<?> clazz, boolean expectedPresent) {
    try {
        Method m = clazz.getDeclaredMethod("$deserializeLambda$", SerializedLambda.class);
        if (!expectedPresent)
            fail("Unexpected $deserializeLambda$ in " + clazz);
    }
    catch (NoSuchMethodException e) {
        if (expectedPresent)
            fail("Expected to find $deserializeLambda$ in " + clazz);
    }
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
private void saveGame() {
	xstream.autodetectAnnotations(true);
	xstream.allowTypes(new Class[] {SerializedLambda.class});
	spritesCopy = new ArrayList<>();
	for (Sprite sprite : spriteModel.getSprites()) {
		spritesCopy.add(sprite.clone());
	}
	savedSpritesXML = xstream.toXML(spritesCopy);
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
public <T> IsPojo<A> where(
    final MethodReference<A, T> methodReference,
    final Matcher<T> returnValueMatcher) {
  final SerializedLambda serializedLambda = serializeLambda(methodReference);

  ensureDirectMethodReference(serializedLambda);

  return where(
      serializedLambda.getImplMethodName(),
      methodReference,
      returnValueMatcher);
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
private static void ensureDirectMethodReference(final SerializedLambda serializedLambda) {
  final Method targetMethod;
  try {
    final Class<?> implClass = Class.forName(serializedLambda.getImplClass().replace('/', '.'));
    targetMethod = findMethodByName(implClass, serializedLambda.getImplMethodName());
  } catch (NoSuchMethodException | ClassNotFoundException e) {
    throw new IllegalStateException(
        "serializeLambda returned a SerializedLambda pointing to an invalid class/method", e);
  }

  if (targetMethod.isSynthetic()) {
    throw new IllegalArgumentException("The supplied lambda is not a direct method reference");
  }
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
default SerializedLambda serialized() {
	try {
		Method replaceMethod = getClass().getDeclaredMethod("writeReplace");
		replaceMethod.setAccessible(true);
		return (SerializedLambda) replaceMethod.invoke(this);
	} catch (Exception ex) {
		throw new RuntimeException(ex);
	}
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
default Method method() {
	SerializedLambda lambda = serialized();
	Class<?> containingClass = getContainingClass();
	return stream(containingClass.getDeclaredMethods())
			.filter(method -> Objects.equals(method.getName(), lambda.getImplMethodName()))
			.findFirst()
			.orElseThrow(UnableToGuessMethodException::new);
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
private static String[] getSerializedLambdaParameterizedTypeNames(Object source) {
	Method method = ReflectionUtils.findMethod(source.getClass(), "writeReplace");
	if (method == null) {
		return null;
	}
	ReflectionUtils.makeAccessible(method);
	SerializedLambda serializedLambda = (SerializedLambda) ReflectionUtils
			.invokeMethod(method, source);
	String signature = serializedLambda.getImplMethodSignature().replaceAll("[()]","");

	List<String> typeNames = Stream.of(signature.split(";"))
			.map(t -> t.substring(1).replace('/', '.')).collect(Collectors.toList());

	return typeNames.toArray(new String[typeNames.size()]);
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
@Override
public boolean matches(Object item) {
	if (!Lambdas.isSerializableLambda(item.getClass())) {
		return false;
	}
	SerializedLambda lambda = Lambdas.serializeLambda(item);
	return lambda.getImplMethodName().equals(name);
}
 

import java.lang.invoke.SerializedLambda; //导入依赖的package包/类
public static SerializedLambda serializeLambda(Object object) {
	try {
		Method writeReplace = object.getClass().getDeclaredMethod("writeReplace");
		return Reflections.accessing(writeReplace).call(m -> (SerializedLambda) m.invoke(object));
	} catch (ReflectiveOperationException e) {
		return null;
	}
}