Java conditional mapping from one object to another?

Looking to build an API that lets the client specify what fields they want projected from the internal Domain object to the external Domain resource

> DB --> Foo Entity --> Foo Mapper --> Foo Resource

Client sends a request parameter called fieldsToProject

e.g.

> fieldsToProject: ["id", "name", "description", "basePrice", "unitPrice", "manufacturer"]

I wrote a very crude method but it works like so

public FooResource toProjectedFooResource(Foo foo, List<String> fieldsToProject) {
    FooResource resource = new FooResource();

    if (fieldsToProject.contains("id")) {
        resource.setId(foo.getId());
    }

    if (fieldsToProject.contains("name")) {
        resource.setName(foo.getName());
    }

    if (fieldsToProject.contains("basePrice")) {
        resource.setBasePrice(foo.getBasePrice());
    }

    if (fieldsToProject.contains("unitPrice")) {
        resource.setUnitPrice(foo.getUnitPrice());
    }
    
    //etc.
    return resource;
}

Is there a neater or cooler way to do this without having a 400 line function with all these if statements?

Also if the client sends the fields with incorrect spelling or case then the solution should just ignore it, not throw an exception.

Note I am using Spring Boot 2.3 with Spring Hateoas + Rest

Using reflection you can create a more compact code indeed. My approach wold be something like this:

    public FooResource toProjectedFooResource(Foo foo, List<String> fieldsToProject) {
		FooResource fr = new FooResource();
		for (Field field : foo.getClass().getDeclaredFields()) {
			if (fieldsToProject.contains(field.getName())) {
				try {
					// Notice the use property descriptor for simplicity instead of constructing the getter setter method name by ourselves
					new PropertyDescriptor(field.getName(), FooResource.class).getWriteMethod().invoke(fr,
							new PropertyDescriptor(field.getName(), Foo.class).getReadMethod().invoke(foo, (Object[]) null));
				} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException
						| IntrospectionException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		return fr;
	}

I'd use a HashSet for the fieldsToProject instead a list, it will perform better.

You can use reflection for this. I did make some simple example for you to see how it works:

public class Main {
public static void main(String[] args) {
List<String> fieldsToProject = Arrays.asList("test1");
Test input = new Test();
input.setTest1("1234");
input.setTest2("5678");
Test result = new Test();
for (String field : fieldsToProject) {
try {
//Fields need to be public for this to work
Field inputField = input.getClass().getField(field);
Field outputField = result.getClass().getField(field);
outputField.set(inputField.get(input), result);
} catch (Exception e) {
e.printStackTrace();
}
try {
//TODO: Place here some function to change field to camel case
String fieldCamelCase = "Test1";
Method inputGetMethod = Arrays.stream(input.getClass().getMethods())
.filter(x -> x.getName().equals("get" + fieldCamelCase))
.findFirst().orElseGet(null);
Method outputSetMethod = Arrays.stream(input.getClass().getMethods())
.filter(x -> x.getName().equals("set" + fieldCamelCase))
.findFirst().orElseGet(null);
Object value = inputGetMethod.invoke(input);
outputSetMethod.invoke(result, value);
} catch (Exception e) {
e.printStackTrace();
}
}
System.out.println(result.getTest1());
System.out.println(result.getTest2());
}
}
public class Test {
private String test1;
private String test2;
public String getTest1() {
return test1;
}
public Test setTest1(String test1) {
this.test1 = test1;
return this;
}
public String getTest2() {
return test2;
}
public Test setTest2(String test2) {
this.test2 = test2;
return this;
}
}

it won't cover every case but it's a place to start.