GenericMappingDemo.java

public class GenericMappingDemo {

 static class A {
 private Integer integerA;
 private String stringA;
 private Float floatA;

 public A(final Integer integerA, final String stringA, final Float floatA) {
 this.integerA = integerA;
 this.stringA = stringA;
 this.floatA = floatA;
 }

 public Integer getIntegerA() {
 return integerA;
 }

 public void setIntegerA(final Integer integerA) {
 this.integerA = integerA;
 }

 public String getStringA() {
 return stringA;
 }

 public void setStringA(final String stringA) {
 this.stringA = stringA;
 }

 public Float getFloatA() {
 return floatA;
 }

 public void setFloatA(final Float floatA) {
 this.floatA = floatA;
 }

 @Override
 public String toString() {
 return "A{integerA=" + integerA + ", stringA='" + stringA + "', floatA=" + floatA + '}';
 }
 }

 static class B {
 private Integer integerB;
 private String stringB;

 public Integer getIntegerB() {
 return integerB;
 }

 public void setIntegerB(final Integer integerB) {
 this.integerB = integerB;
 }

 public String getStringB() {
 return stringB;
 }

 public void setStringB(final String stringB) {
 this.stringB = stringB;
 }

 @Override
 public String toString() {
 return "B{integerB=" + integerB + ", stringB='" + stringB + '\'' + '}';
 }
 }

 static class C {
 private Float floatC;
 private String stringC;

 public Float getFloatC() {
 return floatC;
 }

 public void setFloatC(final Float floatC) {
 this.floatC = floatC;
 }

 public String getStringC() {
 return stringC;
 }

 public void setStringC(final String stringC) {
 this.stringC = stringC;
 }

 @Override
 public String toString() {
 return "C{floatC=" + floatC + ", stringC='" + stringC + "'}";
 }
 }

 static class GenericMapping<C, T> {
 final int id;
 final Class<C> type;
 final Function<C, T> getter;
 final BiConsumer<C, T> setter;

 public GenericMapping(final int id,
 final Class<C> type,
 final Function<C, T> getter,
 final BiConsumer<C, T> setter) {
 this.id = id;
 this.type = type;
 this.getter = getter;
 this.setter = setter;
 }
 }

 static class Mapper {
 // All mappings by class and id
 private final Map<Class<?>, Map<Integer, GenericMapping<?, ?>>> mappings
 = new HashMap<>();

 public void addMapping(GenericMapping<?, ?> mapping) {
 mappings.computeIfAbsent(mapping.type,
 c -> new TreeMap<>()).put(mapping.id, mapping);
 }

 /**
 * Map values from one object to another,
 * using any mapping ids that apply to both classes
 * @param from The object to transfer values from
 * @param to The object to transfer values to
 */
 public <From, To> void map(From from, To to) {
 Map<Integer, GenericMapping<?, ?>> getters
 = mappings.get(from.getClass());
 Map<Integer, GenericMapping<?, ?>> setters
 = mappings.get(to.getClass());
 if (getters == null || setters == null) {
 // Nothing to do
 return;
 }

 // Create a set with the ids in both getters and
 // setters, i.e. the mappings that apply
 Set<Integer> ids = new HashSet<>(getters.keySet());
 ids.retainAll(setters.keySet());

 // Transfer all mappings
 for (Integer id : ids) {
 GenericMapping<From, ?> getter
 = (GenericMapping<From, ?>) getters.get(id);
 GenericMapping<To, ?> setter
 = (GenericMapping<To, ?>) setters.get(id);
 transfer(from, to, getter, setter);
 }
 }

 private <From, To, V> void transfer(final From from,
 final To to, final GenericMapping<From, ?> getter,
 final GenericMapping<To, V> setter) {
 // This will throw an exception if the mappings are invalid
 final V value = (V) getter.getter.apply(from);
 setter.setter.accept(to, value);
 }
 }

 public static void main(String[] args) {
 final Mapper mapper = new Mapper();

 // Mapping definition for class A
 mapper.addMapping(new GenericMapping<>(1, A.class,
 A::getIntegerA, A::setIntegerA));
 mapper.addMapping(new GenericMapping<>(2, A.class,
 A::getStringA, A::setStringA));
 mapper.addMapping(new GenericMapping<>(3, A.class,
 A::getFloatA, A::setFloatA));

 // Mapping definition for class B
 mapper.addMapping(new GenericMapping<>(1, B.class,
 B::getIntegerB, B::setIntegerB));
 mapper.addMapping(new GenericMapping<>(2, B.class,
 B::getStringB, B::setStringB));

 // Mapping definition for class C
 mapper.addMapping(new GenericMapping<>(2, C.class,
 C::getStringC, C::setStringC));
 mapper.addMapping(new GenericMapping<>(3, C.class,
 C::getFloatC, C::setFloatC));

 // Use the mappings
 A a = new A(7, "foo", 3.7f);
 B b = new B();
 C c = new C();

 System.out.printf("A before map: %s%n", a);
 System.out.printf("B before map: %s%n", b);
 System.out.printf("C before map: %s%n", c);

 // This will transfer a.integerA to b.integerB and a.stringA to b.stringB
 mapper.map(a, b);
 // This will transfer a.stringA to c.stringC and a.floatA to c.floatC
 mapper.map(a, c);

 System.out.println();
 System.out.printf("A after map: %s%n", a);
 System.out.printf("B after map: %s%n", b);
 System.out.printf("C after map: %s%n", c);
 }
}