Save and restore view state via reflection

This week I had to write an RCP program that had a simple view. This view needed to remember its contents if you closed the application down and started it back up. The traditional way to do this is to implement the init() and restore() methods of the View class, like this:
 

public class TestView extends ViewPart {
   public void saveState(IMemento memento) {
      // save state here
   }
   public void init(IViewSite site, IMemento memento) throws PartInitException {
      super.init(site, memento);
      // restore from state here
   }
   // ... rest of code
}

Inside these two methods you basically need to serialize and deserialize your state using the IMemento interface. The problem is that every time you change your view (add or remove a control) you would need to remember to change the save and get code as well.

After forgetting that a few times I decided I needed an easier way. Ideally it would "just work" and adjust to any change I made in my view without code changes. This turned out to be easier than I thought by using Java reflection.

The StateUtil class I wrote has static methods called saveState() and init() that mimic the View methods. It's not a direct mapping though because you have to wait until the controls in the view are created by View.createPartControl() before you can actually call StateUtil.init(). So what you do is remember the memento passed into View.init() and then call StateUtil.init() later with that memento when the view has been created.

StateUtil looks like this:
 

/** Utility for saving and restoring fields in a view (could have other uses). */
public class StateUtil {
   // ... other stuff discussed below
 
   /** Save the state of an object into a memento by using reflection. */
   public static void saveState(Object object, IMemento memento) {
      getSaveFields(object, memento, true);
   }
 
   /** Get the state of an object from a memento by using reflection. */
   public static void init(Object object, IMemento memento) {
      getSaveFields(object, memento, false);
   }
}

I wanted to combine the getting and saving together so the code for the two would be very close together. The meat of the class is the getSaveFields() method. It iterates through all the fields and calls a get/save method for each type of field:
 

   private static void getSaveFields(Object object, IMemento memento, boolean save) {
      Class clazz = object.getClass();
      Field[] fields = clazz.getDeclaredFields();
      for (int i = 0; i < fields.length; i++) {
         try {
            Field field = fields[i];
 
            // supress normal Java access checking, otherwise you'll get a security exception
            field.setAccessible(true);
 
            if (field.getType() == Combo.class) {
               getSaveCombo(object, field, memento, save);
            } else if (field.getType() == Text.class) {
               getSaveText(object, field, memento, save);
            }
 
         } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
         } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
         }
      }
   }

Error handling is left as an exercise for the reader. Also note that code requires an exact class match so it doesn't handle subclasses. It's not a problem with SWT but if you were using this for something else you'd probably want to get the actual field and use the instanceof operator.

All that's left is to define your get/save methods for each of your supported types. In this example I'm only supporting Text and Combo fields, so I have:
 

경축! 아무것도 안하여 에스천사게임즈가 새로운 모습으로 재오픈 하였습니다.
어린이용이며, 설치가 필요없는 브라우저 게임입니다.
https://s1004games.com

   private static void getSaveText(Object object, Field field, IMemento memento, boolean save)
         throws IllegalArgumentException, IllegalAccessException {
      Text text = (Text) field.get(object);
      if (save) {
         memento.putString(field.getName(), text.getText());
      } else {
         String value = memento.getString(field.getName());
         if (value != null) {
            text.setText(value);
         }
      }
   }
 
   private static void getSaveCombo(Object object, Field field, IMemento memento, boolean save)
         throws IllegalArgumentException, IllegalAccessException {
      Combo combo = (Combo) field.get(object);
      if (save) {
         memento.putString(field.getName(), combo.getText());
      } else {
         String value = memento.getString(field.getName());
         if (value != null) {
            combo.setText(value);
            if (combo.indexOf(value) == -1)
               combo.add(value);
         }
      }
   }

It doesn't save the whole list of valid combo values but you could add that if you need it. You can also add support for other controls like spinners, radio buttons, and so forth.

That's all there is to it. Of course this isn't the greatest example of design patterns since it mixes the concepts of view and model, but it gets the job done. You should also be able to apply the technique to other things like launch configurations or model data. I hope you find it useful.

[출처] http://www.eclipsezone.com/eclipse/forums/t53813.html