Implement Command Pattern Effectively

Question

Initial code:

public void updateState(final int state)
{
    preSet();
    itsState = state;
    postSet();
}
public void setTitle(final String title)
{
    preSet();
    itsTitle = title;
    postSet();
}

After my Command Pattern Implementation:

public void updateState(final int state)
{
  CallableManager.doInTransaction(new Callable<Void>()
  {
     @Override
     public Void execute()
     {
       itsHiddenNodes = hiddenNodes;
       return null;
     }
  });
}
public void setTitle(final String title)
{
  CallableManager.doInTransaction(new Callable<Void>()
  {
     @Override
     public Void execute()
     {
       itsTitle = title;
       return null;
     }
  });
}

This interface is created for pass method as parameter.

private interface Callable<T>
{
    public T execute();
}

This class is created to manage command pattern.

private class CallableManager
{
    public <T> static void doInTransaction(final Callable<T> callable)
    {
        preSet();
        callable.execute();
        postSet();
    }
}

As you see, implementing command pattern does not look like very effective at least as line of code for this example. For this example, I implement command pattern to escape from repeated code and decrease the line of code. But as a result both of them are not provided for this example. Please give me some advice. How can I use command pattern effectively?

Patterns are not about reducing lines of code. Why are you trying to use this pattern here? — Federico Nafria
– Federico Nafria, Commented Jan 14, 2019 at 21:05
I'd suggest you review this primer. I think it might answer your question. — Tom Drake
– Tom Drake, Commented Jan 14, 2019 at 21:39
@Sha and that is happening. Now the logic to doInTransaction is in a single place, if you need to change it you'll have to change it in a single place. — Federico Nafria
– Federico Nafria, Commented Jan 14, 2019 at 22:33
Having a pattern without knowing what you want to achieve with it makes it hard to come up with a proper implementation. What is the idea behind updateState and setTitle ? — Federico Nafria
– Federico Nafria, Commented Jan 14, 2019 at 22:40

jaco0646 · Accepted Answer · 2019-01-14 23:51:20Z

4

A lambda can reduce the code duplication considerably. Also, Runnable seems like a more appropriate interface than Callable, since you are not returning a value.

public class MainJava {
    private int state;
    private String title;

    public static void main(String... args) {
        MainJava mj = new MainJava();
        mj.setState(42);
        mj.setTitle("My Title");
    }

    public void setState(int state) {
        doInTransaction(() -> this.state = state);
    }
    public void setTitle(String title) {
        doInTransaction(() -> this.title = title);
    }

    private void doInTransaction(Runnable runnable) {
        preSet();
        runnable.run();
        postSet();
    }

    private void preSet() {
        System.out.println("preset");
    }
    private void postSet() {
        System.out.println("post-set");
    }
}

answered Jan 14, 2019 at 23:51

jaco0646

17.4k10 gold badges70 silver badges100 bronze badges

Sign up to request clarification or add additional context in comments.

Collectives™ on Stack Overflow

Implement Command Pattern Effectively

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related