Visitor design pattern with GWT

Question

I had an idea and it goes like this:

Parse a file on service side.
Create a list of actions based on the file's contents.
Pass the list of actions to the client side.
Have the client define and perform actions based on the items on the list.

As in the visitor pattern, we'd have a class for the actions and all of them inherit the Action interface. The clients would then implement the visitors. In Java it'd be something like this:

public interface Action {
    void act(Visitor visitor);
}

public class PerfectAction implements Action {
    void act(Visitor visitor) {
         visitor.bePerfect();
    }
}

public class VisibleAction implements Action {
    void act(Visitor visitor) {
         visitor.beVisible();
    }
}

public interface Visitor {
    void bePerfect();
    void beVisible();
}

The Problem
I can't create Proxy classes for the Action and Visitor interfaces. They do not contain setters and/or getters. Plus they do not contain any data. Is it possible to pass this knowledge of which method should be called on the Visitor object from service to client side?

score 1 · Accepted Answer · answered Sep 06 '12 at 11:10

Request Factory can only move data around (EntityProxy and/or ValueProxy), and ask the server to do things on behalf of the client (RequestContext).

To transfer actions, the client and server first need to share the knowledge of those actions that can be performed.

You then have two solutions:

move to GWT-RPC
because the client has to know every possible action upfront anyway, create an enum or whatever to identify each action, and transfer those identifiers to the client, which will map them back to concrete actions to perform.

score 0 · Answer 2 · answered Sep 06 '12 at 09:24

0

I don't think this is how you'd implement the visitor pattern. I'd do something like this

public interface ActionVisitor {
  void visit(VisibleAction va);
  void visit(PerfrectAction pa);
}

public class PerfectAction implements Action {
    void act(Visitor visitor) {
       visitor.visit(this);
    }
}

public class VisibleAction implements Action {
    void act(Visitor visitor) {
        visitor.visit(this);
    }
}

Then I'd define an implementation of the visitor that performed the appropriate actions.

It's important to define it in this way so that the logic of what the visitor does is external to the class. Prior to this, each implementation had a different implementation of the visitor, so it'd be harder to change behaviour.

I think that this will solve your problem, because now the logic of what to do is externalized to the visitor.

answered Sep 06 '12 at 09:24

Jeff Foster

43,770
11
86
103

The problem isn't the pattern itself. If my understanding of the definition of the Visitor pattern is wrong, then that's beside the issue. The main problem is how to transfer the interface inside GWT. – denarced Sep 06 '12 at 10:03
The only way to transfer the interface into GWT (or make it available to GWT classes), would be to subclass the GWT classes and extend them with your visitor method. – Jeff Foster Sep 06 '12 at 10:07
You mean subclass ValueProxy or EntityProxy? – denarced Sep 06 '12 at 10:52

Visitor design pattern with GWT

2 Answers2