/**
	 * 为了支持Java编程语言中的ambda表达式和方法引用表达式特性，
	 * 本方法提供了一种简便的方式来创建实现一个或多个接口的“函数对象”。这些函数对象是通过委托给一个提供的{@link MethodHandle}，
	 * 在适当的类型适配和参数的部分求值之后实现的。通常作为{@code invokedynamic}调用点的<em>引导方法</em>使用。
	 *
	 * <p>这是标准的、简化的元工厂方法；通过{@link #altMetafactory(MethodHandles.Lookup, String, MethodType, Object...)}
	 * 提供了额外的灵活性。关于此方法的行为的一般描述，请参见{@link LambdaMetafactory}。
	 *
	 * <p>当从此方法返回的{@code CallSite}的目标被调用时，生成的函数对象是实现由{@code invokedType}的返回类型命名的接口的类的实例，
	 * 声明了一个具有由{@code invokedName}和{@code samMethodType}给出的名称和签名的方法。它还可能覆盖来自{@code Object}的额外方法。
	 *
	 * @param caller 表示具有调用者访问权限的查找上下文。当与{@code invokedynamic}一起使用时，这由VM自动堆叠。
	 * @param invokedName 要实现的方法的名称。当与{@code invokedynamic}一起使用时，这由{@code InvokeDynamic}结构的{@code NameAndType}提供，并由VM自动堆叠。
	 * @param invokedType {@code CallSite}的预期签名。参数类型代表捕获变量的类型；返回类型是要实现的接口。当与{@code invokedynamic}一起使用时，这由{@code InvokeDynamic}结构的{@code NameAndType}提供，并由VM自动堆叠。如果实现方法是实例方法并且此签名有任何参数，则调用签名中的第一个参数必须对应于接收者。
	 * @param samMethodType 函数对象要实现的方法的签名和返回类型。
	 * @param implMethod 描述应在调用时调用的实现方法的直接方法句柄（适当地适配参数类型、返回类型，并将捕获的参数前置到调用参数中）。
	 * @param instantiatedMethodType 应在调用时动态强制执行的签名和返回类型。这可能与{@code samMethodType}相同，或可能是其特化版本。
	 * @return 一个CallSite，其目标可用于执行捕获，生成由{@code invokedType}命名的接口的实例
	 * @throws LambdaConversionException 如果违反了{@link LambdaMetafactory}中描述的任何链接不变量
	 */
    public static CallSite metafactory(MethodHandles.Lookup caller,
                                       String invokedName,
                                       MethodType invokedType,
                                       MethodType samMethodType,
                                       MethodHandle implMethod,
                                       MethodType instantiatedMethodType)
            throws LambdaConversionException {
         // 创建一个内部类Lambda元工厂实例，用于生成和验证lambda表达式的实现
		 AbstractValidatingLambdaMetafactory mf;
		 mf = new InnerClassLambdaMetafactory(caller, invokedType,
                                             invokedName, samMethodType,
                                             implMethod, instantiatedMethodType,
                                             false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
        // 验证元工厂方法的参数是否符合要求
        mf.validateMetafactoryArgs();
        // 构建并返回一个CallSite，它是lambda表达式或方法引用的动态调用点
        return mf.buildCallSite();
    }

InnerClassLambdaMetafactory构造函数、buildCallSite构建CallSite调用点

 /**
	 * 构造函数：创建一个内部类Lambda元工厂的实例。
	 * 该构造函数用于支持标准情况以及允许序列化或桥接等不常见选项。
	 *
	 * @param caller 由VM自动堆叠；代表具有调用者访问权限的查找上下文。
	 * @param invokedType 由VM自动堆叠；被调用方法的签名，包括返回的lambda对象的预期静态类型，
	 *                    以及lambda捕获参数的静态类型。如果实现方法是实例方法，调用签名的第一个参数将对应于接收者。
	 * @param samMethodName 转换为lambda或方法引用的函数接口中的方法名称，表示为String。
	 * @param samMethodType 转换为lambda或方法引用的函数接口中的方法类型，表示为MethodType。
	 * @param implMethod 应当被调用的实现方法（适当调整参数类型、返回类型和捕获参数后），当调用结果函数接口实例的方法时。
	 * @param instantiatedMethodType 在从捕获站点实例化类型变量后，主要函数接口方法的签名。
	 * @param isSerializable lambda是否应该是可序列化的？如果设置，目标类型或一个附加的SAM类型必须扩展{@code Serializable}。
	 * @param markerInterfaces lambda对象应该实现的附加接口。
	 * @param additionalBridges 额外的签名，这些签名将被桥接到实现方法。
	 * @throws LambdaConversionException 如果违反了元工厂协议的任何不变量。
	 */
    public InnerClassLambdaMetafactory(MethodHandles.Lookup caller,
                                       MethodType invokedType,
                                       String samMethodName,
                                       MethodType samMethodType,
                                       MethodHandle implMethod,
                                       MethodType instantiatedMethodType,
                                       boolean isSerializable,
                                       Class<?>[] markerInterfaces,
                                       MethodType[] additionalBridges)
            throws LambdaConversionException {
        // 调用父类构造函数，初始化基本参数
	    super(caller, invokedType, samMethodName, samMethodType,
	          implMethod, instantiatedMethodType,
	          isSerializable, markerInterfaces, additionalBridges);
	    // 初始化实现方法的类名，将'.'替换为'/'
	    implMethodClassName = implDefiningClass.getName().replace('.', '/');
	    // 初始化实现方法的名称
	    implMethodName = implInfo.getName();
	    // 初始化实现方法的描述符
	    implMethodDesc = implMethodType.toMethodDescriptorString();
	    // 初始化实现方法返回类型的类
	    implMethodReturnClass = (implKind == MethodHandleInfo.REF_newInvokeSpecial)
	            ? implDefiningClass
	            : implMethodType.returnType();
	    // 初始化生成类构造函数的类型
	    constructorType = invokedType.changeReturnType(Void.TYPE);
	    // 生成并初始化lambda类的名称
	    lambdaClassName = targetClass.getName().replace('.', '/') + "$$Lambda$" + counter.incrementAndGet();
	    // 【重要⭐️⭐️⭐️⭐️⭐️】初始化ASM类写入器
	    cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
	    // 初始化构造函数参数名称和描述符数组
	    int parameterCount = invokedType.parameterCount();
	    if (parameterCount > 0) {
	       // 初始化参数名和参数描述数组，大小为方法参数的数量
			argNames = new String[parameterCount];
			argDescs = new String[parameterCount];
			// 遍历所有参数，生成参数名和参数描述
			for (int i = 0; i < parameterCount; i++) {
			    // 为每个参数生成一个唯一的名称，格式为"arg$序号"
			    argNames[i] = "arg$" + (i + 1);
			    // 使用BytecodeDescriptor工具类将参数类型转换为字符串描述形式
			    argDescs[i] = BytecodeDescriptor.unparse(invokedType.parameterType(i));
			}

	    } else {
	        // 当调用类型参数计数为0时，初始化参数名和参数描述数组为空字符串数组
			argNames = argDescs = EMPTY_STRING_ARRAY;
	    }
    }


   /**
	 * 构建CallSite。生成实现功能接口的类文件，定义类，如果没有参数则创建类的实例，
	 * 该实例将由CallSite返回，否则，生成的句柄将调用类的构造函数。
	 *
	 * @return CallSite，调用时，将返回一个功能接口的实例
	 * @throws ReflectiveOperationException 反射操作异常
	 * @throws LambdaConversionException 如果没有找到正确形式的功能接口
	 */
    @Override
    CallSite buildCallSite() throws LambdaConversionException {
         // 生成实现了函数接口的内部类
	    final Class<?> innerClass = spinInnerClass();
	    // 如果调用类型没有参数，即无需捕获的变量
	    if (invokedType.parameterCount() == 0) {
	        // 通过反射获取一个内部类的所有构造函数，并在只有一个构造函数的情况下，将这个唯一的构造函数设置为可访问的。
	        final Constructor<?>[] ctrs = AccessController.doPrivileged(
	                new PrivilegedAction<Constructor<?>[]>() {
	            @Override
	            public Constructor<?>[] run() {
	            	// 返回了innerClass（内部类）的所有构造函数，包括私有的。
	                Constructor<?>[] ctrs = innerClass.getDeclaredConstructors();
	                if (ctrs.length == 1) {
	                    // 如果只有一个构造函数，设置为可访问
	                    ctrs[0].setAccessible(true);
	                }
	                return ctrs;
	            }
	                });
	        // 确保只有一个构造函数
	        if (ctrs.length != 1) {
	            throw new LambdaConversionException("Expected one lambda constructor for "
	                    + innerClass.getCanonicalName() + ", got " + ctrs.length);
	        }
	
	        try {
	            // 通过构造函数实例化对象
	            Object inst = ctrs[0].newInstance();
	            // 创建并返回一个持有lambda对象的ConstantCallSite
	            return new ConstantCallSite(MethodHandles.constant(samBase, inst));
	        }
	        catch (ReflectiveOperationException e) {
	            throw new LambdaConversionException("Exception instantiating lambda object", e);
	        }
	    } else {
	        // 如果有参数，需要通过静态方法来创建CallSite
	        try {
	            // 确保类已经被完全初始化
	            UNSAFE.ensureClassInitialized(innerClass);
	            // 查找静态方法并创建CallSite
	            return new ConstantCallSite(
	                    MethodHandles.Lookup.IMPL_LOOKUP
	                         .findStatic(innerClass, NAME_FACTORY, invokedType));
	        }
	        catch (ReflectiveOperationException e) {
	            throw new LambdaConversionException("Exception finding constructor", e);
	        }
	    }
    }

/**
	 * 生成并返回一个实现了功能接口的类文件。
	 *
	 * @implNote 生成的类文件不包含SAM方法可能存在的异常签名信息，
	 * 旨在减少类文件大小。这是无害的，因为已检查的异常会被擦除，
	 * 没有人会针对这个类文件进行编译，我们不保证lambda对象的反射属性。
	 *
	 * @return 实现了功能接口的类
	 * @throws LambdaConversionException 如果没有找到正确形式的功能接口
	 */
	private Class<?> spinInnerClass() throws LambdaConversionException {
		// 构建一个字符串数组 interfaces，该数组包含了要实现的接口的内部名称（即将.替换为/的全限定类名），同时确保没有重复的接口，并检查是否意外地实现了 Serializable 接口。
	    String[] interfaces;
	    // 获取函数式接口的内部名称，将.替换为/。
	    String samIntf = samBase.getName().replace('.', '/');
	    // 检查基础函数式接口是否意外实现了 Serializable 接口。
	    boolean accidentallySerializable = !isSerializable && Serializable.class.isAssignableFrom(samBase);
	    // 如果没有额外的标记接口，直接使用函数式接口的内部名称作为 interfaces 的唯一元素。
	    if (markerInterfaces.length == 0) {
	        interfaces = new String[]{samIntf};
	    } else {
	        // 如果 markerInterfaces 非空,确保没有重复的接口（ClassFormatError）,使用 LinkedHashSet 来存储接口名称，确保不会有重复。
	        Set<String> itfs = new LinkedHashSet<>(markerInterfaces.length + 1);
	        // 将函数式接口的内部名称添加到集合中
	        itfs.add(samIntf);
	        // 遍历额外的标记接口，将它们的内部名称添加到集合中，并检查是否意外实现了 Serializable 接口。
	        for (Class<?> markerInterface : markerInterfaces) {
	            itfs.add(markerInterface.getName().replace('.', '/'));
	            accidentallySerializable |= !isSerializable && Serializable.class.isAssignableFrom(markerInterface);
	        }
	        // 将接口名称集合转换为字符串数组。
	        interfaces = itfs.toArray(new String[itfs.size()]);
	    }
		/**
		cw 是 ClassWriter 的实例，它是 ASM（一个通用的 Java 字节码操作和分析框架）库中的一个类。ClassWriter 用于动态生成类或接口的二进制字节码。在上下文中，cw 被用来构建和定义一个新的类，这个类是在运行时动态生成的，用于实现特定的功能接口，通常是为了支持 Java 中的 lambda 表达式。
通过调用 ClassWriter 的方法，如 visit、visitMethod 和 visitField，可以分别定义类的基本信息、方法和字段。最终，通过调用 cw.toByteArray() 方法，可以获取到这个动态生成的类的字节码数组，这个数组可以被加载到 JVM 中，从而创建出一个新的类实例。
		*/
		// 定义了一个类，这个类是final和synthetic的，继承自Object类，并实现了interfaces数组中指定的接口。lambdaClassName是这个类的名称。
		// 其中:
		// 	ACC_FINAL 表示这个类是final的
		//	ACC_SYNTHETIC 表示这个类是synthetic的，synthetic标记表明这个类是由编译器自动生成的，而非直接来自源代码。
		//	lambdaClassName 是动态生成的类名
	    cw.visit(CLASSFILE_VERSION, ACC_SUPER + ACC_FINAL + ACC_SYNTHETIC,
	             lambdaClassName, null,
	             JAVA_LANG_OBJECT, interfaces);
	
	    // 生成构造函数中要填充的最终字段
	    for (int i = 0; i < argDescs.length; i++) {
	    	// 生成一个private final字段来存储这些参数的值。
	        FieldVisitor fv = cw.visitField(ACC_PRIVATE + ACC_FINAL,
	                                        argNames[i],
	                                        argDescs[i],
	                                        null, null);
	        /**
				这行代码的作用是结束一个字段的访问。在ASM中，每当开始定义一个新的字段时，都会通过调用visitField方法返回一个FieldVisitor对象，通过这个对象可以定义字段的属性。当字段的定义结束时，需要调用visitEnd方法来标志这个过程的结束。
			*/                                
	        fv.visitEnd();
	    }
		// 生成构造函数
	    generateConstructor();
		// 判断是检查invokedType（lambda表达式的目标类型）是否有参数。
	    if (invokedType.parameterCount() != 0) {
	    	// 这个方法的作用是生成工厂方法。工厂方法是一个特殊的方法，用于动态生成并返回实现了函数式接口的类的实例。这个过程通常涉及到字节码的生成和类的加载。
	        generateFactory();
	    }
	
	    /**
		    这行代码通过调用 ClassWriter 的 visitMethod 方法创建了一个新的方法。这个方法的访问级别是 public，方法名是 samMethodName，这是一个从外部传入的参数，表示要实现的SAM接口中的方法名。samMethodType.toMethodDescriptorString() 将方法的签名转换为字符串形式，用于定义方法的参数类型和返回类型。最后两个 null 参数分别表示这个方法的签名和异常，这里不使用这些高级特性，所以传入 null。
		*/
	    MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, samMethodName,
	                                      samMethodType.toMethodDescriptorString(), null, null);
	    // 这行代码给刚才创建的方法添加了一个注解 LambdaForm$Hidden。这个注解是内部使用的，用于标记这个方法不应该被外部调用或者看到。true 参数表示这个注解是在运行时可见的。
	    mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
	    // 这行代码实际上是生成方法体的关键步骤。它创建了一个 ForwardingMethodGenerator 对象，这个对象负责生成方法体的字节码。generate 方法接受一个 MethodType 对象 samMethodType 作为参数，这个对象描述了SAM接口方法的参数类型和返回类型。generate 方法根据这个信息，动态生成字节码，这些字节码实现了将调用转发到实际的目标方法上。
	    new ForwardingMethodGenerator(mv).generate(samMethodType);
	
	
	    /**
			这段代码的主要作用是为了生成桥接方法（Bridge Methods），这些方法用于处理泛型擦除后的类型不匹配问题。在Java中，泛型信息在编译时会被擦除，而桥接方法则用于在运行时保持类型的正确性。这段代码是在动态生成的类中添加这些桥接方法的过程。
	    */
	    // additionalBridges 是一个包含了需要生成桥接方法的 MethodType 对象的数组。
	    if (additionalBridges != null) {
	        for (MethodType mt : additionalBridges) {
	        	// 为每个桥接方法类型生成方法：通过调用 cw.visitMethod 方法生成桥接方法。这里的 cw 是一个 ClassWriter 对象，用于动态生成类的字节码。ACC_PUBLIC|ACC_BRIDGE 是方法的访问标志，表示这是一个公开的桥接方法。samMethodName 是要实现的函数式接口的方法名，mt.toMethodDescriptorString() 将方法类型转换为方法描述符字符串，用于指定方法的签名。
	            mv = cw.visitMethod(ACC_PUBLIC|ACC_BRIDGE, samMethodName,
	                                mt.toMethodDescriptorString(), null, null);
				// 添加方法注解：通过调用 mv.visitAnnotation 方法为生成的桥接方法添加注解。这里的注解是 "Ljava/lang/invoke/LambdaForm$Hidden;"，表示这个方法是由lambda表达式生成的，不应该被直接调用。
	            mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
	            // 生成方法体：通过创建一个新的 ForwardingMethodGenerator 对象并调用其 generate 方法来生成桥接方法的方法体。这个方法体基本上是将调用转发到实际的实现方法上。
	            new ForwardingMethodGenerator(mv).generate(mt);
	        }
	    }
	
		/**
			这段代码的作用是根据是否需要序列化，生成对应的方法。具体来说，如果需要生成的类是可序列化的，则生成序列化友好的方法；如果不是故意的可序列化（即无意中成为可序列化的），则生成序列化敌对的方法。最后，调用 cw.visitEnd() 来完成类的定义。

				1.判断是否需要序列化：通过 if (isSerializable) 判断，如果 isSerializable 为 true，则表示需要生成的类是可序列化的，此时会调用 generateSerializationFriendlyMethods() 方法生成序列化友好的方法。
				2.判断是否无意中成为可序列化：如果 isSerializable 为 false，则进入 else if (accidentallySerializable) 判断，accidentallySerializable 为 true 表示类无意中成为了可序列化的（例如，通过实现了某个可序列化的接口）。此时会调用 generateSerializationHostileMethods() 方法生成序列化敌对的方法，这可能是为了避免序列化带来的潜在问题或性能影响。
				3.完成类的定义：无论是否需要序列化，最后都会执行 cw.visitEnd()，这是ASM库中的方法，用于完成类的定义。这一步是生成类文件的最后一步，标志着类定义的结束。
		*/
	    if (isSerializable)
	        generateSerializationFriendlyMethods();
	    else if (accidentallySerializable)
	        generateSerializationHostileMethods();
	
	    cw.visitEnd();
	
		// 这行代码调用 ClassWriter 对象的 toByteArray 方法，将动态生成的类转换为字节码数组。cw 是 ClassWriter 的实例，它负责生成类的字节码。
	    final byte[] classBytes = cw.toByteArray();
	
		/**
			这段代码首先检查 dumper 对象是否为 null。dumper 是一个可能用于将字节码写入文件的工具对象。如果 dumper 不为 null，则执行以下步骤：
				1.使用 AccessController.doPrivileged 方法执行一个特权操作。这是因为写入文件可能需要特定的权限，特别是在启用了安全管理器的环境中。
				2.在 doPrivileged 方法中，执行一个 PrivilegedAction，其 run 方法调用 dumper.dumpClass 方法，将类名 lambdaClassName 和字节码数组 classBytes 传递给它，以便将字节码写入文件。
				3.doPrivileged 方法的第二个参数是 null，表示不使用特定的 AccessControlContext。
				4.第三和第四个参数是 FilePermission 和 PropertyPermission 对象，分别授予读写所有文件的权限和读取用户当前目录的权限。这些权限是执行文件写入操作所必需的。
		*/
	    // 转储到文件
	    if (dumper != null) {
	        AccessController.doPrivileged(new PrivilegedAction<Void>() {
	            @Override
	            public Void run() {
	                dumper.dumpClass(lambdaClassName, classBytes);
	                return null;
	            }
	        }, null,
	        new FilePermission("<<ALL FILES>>", "read, write"),
	        // 创建目录可能需要它
	        new PropertyPermission("user.dir", "read"));
	    }
	    /**
	    	1.代码的作用
				下面这段代码的作用是在运行时动态定义一个匿名类。UNSAFE.defineAnonymousClass 方法接收三个参数：目标类（targetClass），类的字节码（classBytes），以及与类相关联的常量池补丁（这里传入的是 null）。
			2.代码的结构和逻辑
				2.1 targetClass：这是一个 Class 对象，表示新定义的匿名类将与之关联的上下文。通常，这个类是匿名类逻辑上的“宿主”类。
				2.2 classBytes：这是一个字节数组，包含了新匿名类的字节码。这些字节码通常是通过某种字节码生成库（如ASM）动态生成的。
				2.3 null：这个参数是用于类定义时的常量池补丁，这里传入 null 表示不需要进行常量池的补丁。
			3.关键代码块或语句的解释
				3.1 UNSAFE：这是 sun.misc.Unsafe 类的一个实例。Unsafe 类提供了一组底层、危险的操作，通常不推荐在标准Java代码中使用。但在某些特殊场景下，如动态类生成、低级并发控制等，Unsafe 提供的功能是必需的。
				3.2 .defineAnonymousClass(targetClass, classBytes, null)：这个方法调用是动态定义匿名类的关键。它将 classBytes 中的字节码转换为一个Java类，并将这个新类与 targetClass 关联起来。由于这个类是匿名的，它没有正式的类名。传入的 null 参数表示在定义类的过程中不需要对常量池进行任何补丁操作。
	    */
	
		// 通过 Unsafe 类的 defineAnonymousClass 方法动态定义了一个匿名类，这个类的字节码由 classBytes 提供，而这个匿名类在逻辑上与 targetClass 关联。
	    return UNSAFE.defineAnonymousClass(targetClass, classBytes, null);
	}