Java 17 中 Lambda this 引用反射操作的挑战与解决方案

package test;

import org.junit.Assert;
import org.junit.Test;

import java.lang.reflect.Field;
import java.util.function.Consumer;

public class LambdaArg1ReflectionTest {
    @Test
    public void test() throws IllegalAccessException {
        // 创建一个捕获了当前实例 (this) 的 Lambda
        Consumer<String> lambda = s -> this.parseInt(s, 7);

        // 获取 Lambda 中捕获的 "this" 引用字段
        // 注意：Lambda 的内部实现是 JVM 细节，字段名称和顺序可能因版本而异
        Field lambda_arg1_field = lambda.getClass().getDeclaredFields()[0];
        lambda_arg1_field.setAccessible(true);
        Object lambda_arg1_value = lambda_arg1_field.get(lambda);

        // 验证捕获的 "this" 引用与当前实例相同
        Assert.assertEquals(this, lambda_arg1_value);

        // 尝试重新赋值同一个值
        // 在 Java 17 中，这一行会抛出 IllegalAccessException
        lambda_arg1_field.set(lambda, lambda_arg1_value); 
    }

    private int parseInt(String s, int i) {
        return Integer.parseInt(s + i);
    }
}

java.lang.IllegalAccessException: Can not set final test.LambdaArg1ReflectionTest field test.LambdaArg1ReflectionTest$$Lambda$40/0x0000000800c191a8.arg$1 to test.LambdaArg1ReflectionTest
    at java.base/jdk.internal.reflect.UnsafeFieldAccessorImpl.throwFinalFieldIllegalAccessException(UnsafeFieldAccessorImpl.java:76)
    at java.base/jdk.internal.reflect.UnsafeFieldAccessorImpl.throwFinalFieldIllegalAccessException(UnsafeFieldAccessorImpl.java:80)
    at java.base/jdk.internal.reflect.UnsafeQualifiedObjectFieldAccessorImpl.set(UnsafeQualifiedObjectFieldAccessorImpl.java:79)
    at java.base/java.lang.reflect.Field.set(Field.java:799)
    at test.LambdaArg1ReflectionTest.test(LambdaArg1ReflectionTest.java:23)

package test;

import org.junit.Assert;
import org.junit.Test;

import java.util.function.BiConsumer;
import java.util.function.Consumer;

public class LambdaArg1ReflectionTest {
    // 原始方法，用于演示
    private int parseInt(String s, int i) {
        return Integer.parseInt(s + i);
    }

    @Test
    public void testOriginalLambdaBehavior() {
        // 原始 Lambda 捕获 this
        Consumer<String> lambda = s -> this.parseInt(s, 7);
        // 调用时，隐式使用当前实例
        Assert.assertEquals(1237, parseInt("123", 7)); // 确保 parseInt 方法功能正常
    }

    @Test
    public void testWithBiConsumerWorkaround() {
        // 创建一个 BiConsumer，它显式地接受一个 LambdaArg1ReflectionTest 实例作为第一个参数
        BiConsumer<LambdaArg1ReflectionTest, String> biLambda = (obj, s) -> obj.parseInt(s, 7);

        // 创建一个目标实例
        LambdaArg1ReflectionTest targetInstance = new LambdaArg1ReflectionTest();
        // 调用 biLambda，并传入目标实例
        int result = targetInstance.parseInt("456", 7); // 模拟调用
        // 验证 biLambda 可以在目标实例上正确执行
        Assert.assertEquals(4567, result);

        // 假设我们有一个 Spy 对象（这里用另一个实例简单模拟）
        LambdaArg1ReflectionTest spyInstance = new LambdaArg1ReflectionTest();
        // 我们可以将 spyInstance 传入 biLambda
        int spyResult = spyInstance.parseInt("789", 7); // 模拟在 spy 上调用
        Assert.assertEquals(7897, spyResult);

        // 注意：biLambda 本身并不直接调用 parseInt，它只是定义了如何调用
        // 实际的调用发生在 biLambda.accept(obj, s) 内部
        // 为了演示，我们直接调用了 spyInstance.parseInt
        // 在实际的测试场景中，你可能会用 Mockito 等框架创建真正的 Spy/Mock
    }

    // 假设这是用于测试的 Spy 对象，它可能记录了方法的调用
    public static class SpyLambdaArg1ReflectionTest extends LambdaArg1ReflectionTest {
        private String lastCalledS;
        private int lastCalledI;

        @Override
        public int parseInt(String s, int i) {
            this.lastCalledS = s;
            this.lastCalledI = i;
            System.out.println("Spy parseInt called with s=" + s + ", i=" + i);
            return super.parseInt(s, i);
        }

        public String getLastCalledS() {
            return lastCalledS;
        }

        public int getLastCalledI() {
            return lastCalledI;
        }
    }

    @Test
    public void testWithBiConsumerAndSpy() {
        // 定义 BiConsumer
        BiConsumer<LambdaArg1ReflectionTest, String> biLambda = (obj, s) -> obj.parseInt(s, 7);

        // 创建 Spy 对象
        SpyLambdaArg1ReflectionTest spy = new SpyLambdaArg1ReflectionTest();

        // 通过 biLambda 调用 spy 对象的方法
        // 注意：BiConsumer 的 accept 方法是 void，如果需要返回值，可能需要使用 Function 或 BiFunction
        // 这里我们只是演示如何将 spy 传入
        // biLambda.accept(spy, "100"); // 实际应用中会这样调用

        // 为了演示返回值和捕获参数，我们直接调用 spy 的方法，并验证其行为
        int result = spy.parseInt("100", 7);
        Assert.assertEquals(1007, result);
        Assert.assertEquals("100", spy.getLastCalledS());
        Assert.assertEquals(7, spy.getLastCalledI());
    }
}