Question

The title might seem unsettling, but let me explain.

I’m facing an interesting challenge, where I have a hierarchy of classes that have associated an object that stores metadata related to each one of its attributes (an int-valued enum with edit flags like UPDATED or NO_UPDATE).

The problem comes when merging two objects, because I dont want to check EVERY field on a class to see if it was updated and skip or apply the changes.

My idea: Reflection.

All the objects are behind an interface, so I could use IObject.class.getMethods() and iterate over that array in this fashion:

IClass class = //Instance of the first class;
IAnotherClass anotherClass = //Instance of the second class;
for(Method m  : IObject.class.getMethods()) {
    if(m.getName().startsWith("get")) {
        try {
            //Under this method (which is a getter) I cast it on 
            //both classes who implement interfaces that extend an
            //interface that defines the getters to make them
            //consistent and ensure I'll invoke the same methods.
            String propertyClass = (String)m.invoke(class);
            String propertyAnotherClass = (String)m.invoke(anotherClass);
            if(propertyClass != propertyAnotherClass) {
                //Update attribute and attribute status.
            }
        } catch (Exception e) {

        }
    }
}

Is there another way to implement this or should I stick to lengthy methods invoking attribute per attribute and doing the checks like that?. The objects are not going to change that much and the architecture is quite modular, so there is not much update involved if the fields change but having to change a method like that worries me a little.

EDIT 1: I’m posting a working code of what I have got so far. This code is a solution for me but, tough it works, I’m using it as a last resource not because I have time to spend but because I don’t want to rediscover the wheel. If I use it, I’ll make a static list with the methods so I only have to fetch that list once, considering the fact that AlexR pointed out.

private static void merge(IClazz from, IClazz to) {
        Method methods[] = from.getClass().getDeclaredMethods();
        for(Method m : methods) {
            if(m.getName().startsWith("get") && !m.getName().equals("getMetadata")) {
                try {                   
                    String commonMethodAnchor = m.getName().split("get")[1];
                    if(!m.getReturnType().cast(m.invoke(from)).equals(m.getReturnType().cast(m.invoke(to)))) {
                        String setterMethodName = "set" + commonMethodAnchor;
                        Method setter = IClazz.class.getDeclaredMethod(setterMethodName, m.getReturnType());
                        setter.invoke(to, m.getReturnType().cast(m.invoke(from)));
                        //Updating metadata
                        String metadataMethodName = "set" + commonMethodAnchor + "Status";
                        Method metadataUpdater = IClazzMetadata.class.getDeclaredMethod(metadataMethodName, int.class);
                        metadataUpdater.invoke(to.getMetadata(), 1);
                    }

                } catch (Exception e) {

                }
            }
        }
    }

metadataUpdater sets the value to 1 just to simulate the “UPDATED” flag I’m using on the real case scenario.

EDIT 3: Thanks Juan, David and AlexR for your suggestions and directions! They really pointed me to consider things I did not consider at first (I’m upvoting all your answers because all of them helped me).

After adding what AlexR sugegsted and checking jDTO and Apache Commons (finding out that in the end the general concepts are quite similar) I’ve decided to stick to my code instead of using other tools, since it is working given the object hierarchy and metadata structure of the solution and there are no exceptions popping up so far. The code is the one on the 2nd edit and I’ve placed it on a helper class that did the trick in the end.

Answer 1

Your approach is OK, but keep in mind that getMethod() is much slower than invoke(), so if your code is performance critical you will probably want to cache the Method objects.