Pass in functionality to a method without any further changes to the class

I have the following logic which works fine where I am iterating an object and replacing string values if applicable.

But I am trying to make this more generic: I want the replace logic to come externally.

It is because I want the flexibility to be able to add on more manipulation functionality as needed.

I don't want to keep coming into this class and modify it each time. Instead looking to make it configurable.

Is there any approach I could take to achieve this?

For example I may want another logic where if the value is a string, I want to append "hello" to the string.

I don't want to do this:

private String addHello(String value) {
    return value + "hello";
}

// then in the parse method. 
if (fieldValue instanceof String) {
    field.set(obj, switchName((String) fieldValue));
    field.set(obj, addHello((String) fieldValue)); // new hello logic inserted
}

This would mean I am amending the class every time. Not exactly following SOLID principle.

It should be closed for modifications.

I am looking for advice on how I could turn this into being configurable so that I can stop touching the following implementation, but still be able to add on further logic to it.

import org.apache.commons.lang.reflect.FieldUtils;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.List;
import java.util.Map;

@Component
public class Helper {

    @SuppressWarnings("unchecked")
    public void parse(Object obj) throws IllegalAccessException {
        if (obj == null) {
            return;
        }

        for (Field field : obj.getClass().getDeclaredFields()) {
            field.setAccessible(true);
            int modifiers = field.getModifiers();
            Object fieldValue = FieldUtils.readField(obj, field.getName(), true);
            if (fieldValue instanceof String) {
                field.set(obj, switchName((String) fieldValue));
            }
            else {
                parse(fieldValue);
            }
        }
    }

    private String switchName(String value) {
        return value.replace("apple", "orange");
    }
}

If you just want to replace fields referencing a String, you could pass in a Function<String,String>.

public void parse(Object obj, 
   java.util.function.Function<String,String> replaceFn ) 
throws IllegalAccessException { ... }

If you want to be more general, you could pass in something that accepts an object and a field, and does something with it. Defining that as a specific interface makes it easier to find all implementations.

@FunctionalInterface
public interface IFieldReplacer {
	public void accept(Object o, Field f) throws IllegalAccessException;
}

public class MyFieldReplacerA implements IFieldReplacer {

	@Override
	public void accept(Object o, Field f) 
    throws IllegalAccessException {

		// TODO Get the value, transmogrify it, and set it.

	}
}

public void parse(Object obj, IFieldReplacer fieldReplacer ) {
  ...
}

Both of these allow the caller to pass in a lambda expression.