How to make this part of code scalable,

There is a part in my java code where I am extending a class from a library which I haven't written.

@override
public Object getPropertyValue(Obj开发者_Go百科ect id) {
    if(id.equals(model.PROPERTY_RENAME))
        model.setName((String)value);
    else if(id.equals(model.PROPERTY_COLOUR))
        model.setColor((Color)value);
}

Now in this case how should I modify this code to make it scalable. There would be many more properties like location, dimension, etc. Now this model is instance of an abstract class AbsModel.

So every class implementing the AbsModel would have different properties. So the class architecture should be there, so that this part of code remains unchanged, no matter how many more model classes I add.

It looks like you want to carry out some operation on the model when this method (getPropertyValue) is called. I would create a Map of id onto the interface ModelOperation defined as follows:

public interface ModelOperation {
    void operate(Object value);
}

Then the map would be defines as follows:

map.put(model.PROPERTY_RENAME, new RenameOperation(model));

Your extension class would then look like this:

@Override
public Object getPropertyValue(Object id) {
    map.get(id).operate(model);
    // etc...
}

For example, RenameOperation would be defined like this:

public class RenameOperation implements ModelOperation {
    public RenameOperation(Model model) {
        // etc...
    }

    public void operate(Object value) {
        model.setName((String)value);
    }
}

This allows you to support as many model operations as you like and means you don't have to change the extension class you have to write. The above is just an outline. You could use generics on the ModelOperation implementations to avoid the cast of the value in each one.

I guess reflection is probably the answer here if you can rely on some naming to help direct you.

It's not going to be nice, but the idea would be that you'd have a method that would reflect on the type and look up the appropriate method. The code belwo

public Object setPropertyValue(Object id) {
    String className = id.getClass().getSimpleName();

    // Hope that the method is called set<CLASS> and takes a single parameter that is the class
    Method method = model.class.getMethod("set" + className, id.getClass());

    // Invoke the method (TODO deal with all of the exceptions)
    method.invoke(model, id);
}

There are multiple ways of doing this -- though it depends on what do you mean by "scalable" (being able to cope with lots of requests per second or being able to cope with lots of properties?):

• one way -- if you're going to go down the path you have outlined in your code is to have those properties that are used very often at the top of your if/then/else block -- so their execution path is very short. this would "scale up" well for lots of requests as not too much time is being spent in actually executing the method (in most cases at least!)
• another way -- and this scales up well for lots of properties and easiness of maintaining the code but you will take a hit on execution time: have a Map that maps property names to setxxx() method names, then you can use reflection to invoke these methods on the target object (id in your case) on each call. Classes extended your class will only have to provide a getMap() method which will return the mapping name-to-setter method, which can be a static member and initialized on class load.
• Store your properties in a Map -- in which case setName() is the same as map.put( PROPERTY_RENAME, value)

Since in Java functions are not first class citizens, the "nice" route would be very awkward: define an enum with one value per each constant above (i.e. for each property), and a virtual method e.g. update(Object value, then override the method in each enum to update the corresponding property. If you can, redefine the constants PROPERTY_RENAME etc. themselves as enums. This still results in code bloat.

The other way is to use reflection. If you can use the same ids as the property names you want to update, you only need to invoke the setter for the property (as illustrated in other answers). Otherwise you may need to introduce a mapping from ids to property names.

A version not using reflection, call the base class's implementation:

public Object getValue(Object id) {
  Object ret = super.getValue(id);
  if (ret == null) {
     // Subclass specific properties
  }
  return ret;
}

A common way around this is to use reflection like

public Object getValue(IdType id) {
    Method getter = model.getClass().getMethod("get" + id);
    return getter.invoke(model); // throws Exceptions.
}

OR

public void setValue(IdType id, Object value) {
    Method setter = model.getClass().getMethod("set" + id, value.getClass());
    setter.invoke(model, value); // throws Exceptions.
}

I solved this issue by creating an interface. So the code is.

public interface IModel
{
  public void setProperty(String propertyName); 
}

Rest of the classes were

public class HelloModel implements IModel
{
       public void setProperty(String propertyName)
       { code for handling the properties goes here ... }
}

So in this case every class has to handle it's own property setters. Is this the best way to handle abstraction ? I think this model is very scalable ...