如何使用lambda表达式创建“getter”

Question

I have an object in use throughout my codebase, UnsecureObject . This object is auto-generated with no getters/setters, and all member fields are public. So editing is done by doing something like the following:

unsecureObjInstance.firstName = "Jane";

This is not desirable for numerous reasons that I probably don't have to explain here. But using this generated class is required for some other technical details with our messaging pipeline that I won't go into.

I have a desire is to leverage a mapping utility written by someone else on my team to convert this UnsecureObject to a pojo that I am writing.

An example of the mapper in action (with two normal classes w/ getters/setters) would be something like:

new MapperBuilder<>(PojoOne.class, PojoTwo.class)
      .from(PojoOne::getName).to(PojoTwo::getFirstName)
      .build();

This will map the PojoOne#name field to the PojoTwo#firstName field.

Is there a way to translate this to input my UnsecureObject here? I have tried something like the following:

new MapperBuilder<>(UnsecureObject.class, SecureObject.class)
      .from(u -> u.firstName).to(SecureObject::getFirstName)
      .build();

But get an error here, something along the lines of 'u -> u.firstName' could not be invoked.

So the question is:

Is there a way to essentially "construct" a getter on the fly using these public members? So in the .from() method, I can construct the call to look like a standard method that will yield my u.firstName?

Thanks for the help!

EDIT:

this is approx what the MapperBuilder class looks like (attempted to edit a bit to take away project specific wrappers/simplify)

/**
 * This class is used to convert between POJO getter method references to the corresponding field names.
 * @param <B> type
 */
public interface PojoProxy<B> {

  /**
   * Invokes the given getter method and returns information about the invocation.
   * @param getter the getter to invoke
   * @return information about the method invoked
   */
  <T> GetterInvocation<T> invokeGetter(Function<B, T> getter);

}

/**
 * Stores information about a method invocation.
 * @param <T> method return type
 */
public interface GetterInvocation<T> {

  public Class<T> getReturnType();

  public String getFieldName();

}


/**
 * A builder class to create {@link Mapper} instances.
 * @param <FROM> source type
 * @param <TO> target type
 */
public class MapperBuilder<FROM, TO> {

  private final Class<FROM> _fromClass;
  private final Class<TO> _toClass;
  private final PojoProxy<FROM> _fromProxy;
  private final PojoProxy<TO> _toProxy;

  public MapperBuilder(Class<FROM> fromClass, Class<TO> toClass) {
    _fromClass = fromClass;
    _toClass = toClass;

    //We will pretend there is an impl that provides the proxy.
    //Proxies wrap the from and to classes in order to get reflection information about their getter calls.
    _fromProxy = PojoProxy.of(fromClass);
    _toProxy = PojoProxy.of(toClass);
  }

  public <FROM_VALUE> ToFieldBuilder<FROM_VALUE> from(Function<FROM, FROM_VALUE> getter) {
    GetterInvocation<FROM_VALUE> methodInvocation = _fromProxy.invokeGetter(getter);
    return new ToFieldBuilder<>(methodInvocation.getFieldName(), methodInvocation.getReturnType());
  }

  public class ToFieldBuilder<FROM_VALUE> {

    private final String _fromFieldPath;
    private final Class<FROM_VALUE> _fromClass;

    public ToFieldBuilder(String fromFieldPath, Class<FROM_VALUE> fromClass) {
      _fromFieldPath = fromFieldPath;
      _fromClass = fromClass;
    }

    public <TO_VALUE> FromFieldBuilder<FROM_VALUE, TO_VALUE> to(Function<TO, TO_VALUE> getter) {
     //similar to above, but now using a FromFieldBuilder.
    }
  }

  public class FromFieldBuilder<FROM_VALUE, TO_VALUE> {

   //impl..
  }
}

Answer 1

I dont see MapperBuilder.from() method details, you can try this implementation of MapperBuilder.java Function (getter) -> (BiConsumer) setter

public class MapperBuilder<S, D> {

    private final S src;
    private final D dest;

    public MapperBuilder(S src, Class<D> dest) {
        this.src = src;
        try {
            this.dest = dest.newInstance();
        } catch (Exception e) {
            throw new RuntimeException("Required default constructor for: " + dest);
        }
    }

    //getter  - function to get value from source instance
    //setter  - biConsumer to set value to destination instance
    //example - map(SrcClass::getSrcValue, DestClass::setDestValue)
    public <V> MapperBuilder<S, D> map(Function<S, V> getter, BiConsumer<D, V> setter) {
        setter.accept(dest, getter.apply(src));
        return this;
    }

    public D build() {
        return dest;
    }

}

SrcClass.java some source class:

public class SrcClass {

    private String srcValue;

    public String getSrcValue() {
        return srcValue;
    }

    public void setSrcValue(String srcValue) {
        this.srcValue = srcValue;
    }

}

DestClass.java some destination class:

package com.example.demo;

public class DestClass {

    private String destValue;

    public String getDestValue() {
        return destValue;
    }

    public void setDestValue(String destValue) {
        this.destValue = destValue;
    }

}

DemoApplication.java demo:

public class DemoApplication {

    public static void main(String[] args) {

        SrcClass src = new SrcClass();
        src.setSrcValue("someValue");

        DestClass dest = new MapperBuilder<>(src, DestClass.class)
                .map(SrcClass::getSrcValue, DestClass::setDestValue)
                // map another fields
                .build();

        // for your UnsecureObject case
        UnsecureObject unsecureObject = new MapperBuilder<>(src, UnsecureObject.class)
                .map(SrcClass::getSrcValue, 
                        (unsecure, srcValue) -> unsecure.unsecureValue = srcValue)
                .build();

    }

}