proxy2 | faster proxy generator than java.lang.reflect.Proxy | Code Editor library

org.springframework.boot:spring-boot-starter-hateoas is indeed incompatible with org.springframework.boot:spring-boot-starter-webflux so instead of using org.springframework.boot:spring-boot-starter-hateoas, pull in the Spring HATEOAS dependency itself:

After some research I found this issue on the spring-security project, which describes the issue in a more informative way https://github.com/spring-projects/spring-security/issues/9787

Found the solution:

It may be caused by mybatis-plus, refer to this： https://github.com/zhangdaiscott/jeecg-boot/issues/1886

There’s a mismatch between the requested class name SchemasEnumBaseNameReqProp1 and the name stored in the class file SchemasEnumBasenameReqProp1.

Since this difference is only in the case of the N character, the attempt to load the class file succeeded due to the use of a case insensitive filesystem. But when trying to define an actual runtime class for the file, the JVM detects a name mismatch and throws an error.

In your vavr based transformation pipeline you have

I found the solution directly after posted this question.

It was very easy I forgot to add the "." before env when created the file.

I found the solution here: https://github.com/laradock/laradock/issues/1437

It seems that there is no MS Class to get this information but I came across following PS project: https://gist.github.com/XPlantefeve/a53a6af53b458188ee0766acc8508776

so I took some hours to translate it to c#. I hope I havent made any big mistake but it seems to be working:

TDLR;

1. Private access requires the context of operation to be set to the object that created the private member (Proxy solution provided)
2. For the use case and contrived code you supplied, a Proxy is not required as simple inheritance can be used to accomplish the goal (solution at very bottom)

The no-op Proxy in the first example is not broken. The get() method is still invoked via the Proxy object (even no-op) and not the thing object. So the private member is not accessible via the proxy with proxy1.value. Your fix in the first example, using reflection, is the common way of accessing those members in almost every language with access restrictions (some require inflection). Historically, before Reflect.get() was available, this was done using the function object's .apply() method. So the use of Reflect.get() makes sense for the very same reason.

Bottom Line:

So you must take some action to set the context to the object that created the private member, otherwise you will not gain access to it.

The call to Reflect.get() doesn't work in the second example because of shifting getter syntax from get value() to value(). Now that a function is called to retrieve value it must be bound to the correct object. Simple reflection is not sufficient. To make Reflect.get() work here you must bind the getter function to the target.

Using function's .bind() method is the other traditional way of controlling the context of operation. From the docs:

The bind() method creates a new function that, when called, has its this keyword set to the provided value...

Reflect.get(target, key).bind(target)

Which is exactly the same as your use of .bind() in this:

target[key].bind(target)

The static Reflect.get() method works like getting a property from an object (target[propertyKey]) as a function.

Bottom Line

In both cases (Reflect.get(), .bind()), the context is shifted to the object that created the private member. This is necessary in many use cases and is not isolated to Proxy.