3

I've been asking some questions about adapting the command protocol for use in my client server environment. However, after some experimentation, I have come to the conclusion that it will not work for me. It is not designed for this scenario. I'm thus at a loose end.

I have implemented a sort of RPC mechanism before whereby I had a class entitled "Operation". I also had an enum entitled "Action" that contained names for actions that could be invoked on the server.

Now, in my old project, every time that the client wanted to invoke an action on the server, it would create an instance of 'Operation' and set the action variable with a value from the "Action" enum. For example

Operation serverOpToInvoke = new Operation();
serverOpToInvoke.setAction(Action.CREATE_TIME_TABLE);
serverOpToInvoke.setParameters(Map params);
ServerReply reply = NetworkManager.sendOperation(serverOpToInvoke);
...

On the server side, I had to perform the horrible task of determining which method to invoke by examining the 'Action' enum value with a load of 'if/else' statements. When a match was found, I would call the appropriate method.

The problem with this was that it was messy, hard to maintain and was ultimately bad design.

My question is thus - Is there some sort of pattern that I can follow to implement a nice, clean and maintainable rpc mechanism over a TCP socket in java? RMI is a no go for me here as the client (android) doesn't support RMI. I've exhausted all avenues at this stage. The only other option would maybe be a REST service. Any advice would be very helpful.

Thank you very much Regards

Improve this question

3 Answers 3

Reset to default
9
+50

Probably the easiest solution is to loosely follow the path of RMI.

You start out with an interface and an implementation:

interface FooService  {
  Bar doThis( String param );
  String doThat( Bar param );
}

class FooServiceImpl implements FooService {
  ...
}

You deploy the interface to both sides and the implementation to the server side only.

Then to get a client object, you create a dynamic proxy. Its invocation handler will do nothing else but serialize the service classname, the method name and the parameters and send it to the server (initially you can use an ObjectOutputStream but you can use alternative serialization techniques, like XStream for example).

The server listener takes this request and executes it using reflection, then sends the response back.

The implementation is fairly easy and it is transparent from both sides, the only major caveat being that your services will effectively be singletons.

I can include some more implementation detail if you need, but this is the general idea I would follow if I had to implement something like that.

Having said that, I'd probably search a bit more for an already existing solution, like webservices or something similar.

Update: This is what an ordinary (local) invocation handler would do.

class MyHandler implements InvocationHandler {

    private Object serviceObject;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        return method.invoke(serviceObject, args);
    }
}

Where serviceObject is your service implementation object wrapped into the handler.

This is what you have to cut in half, and instead of calling the method, you need to send the following to the server:

  1. The full name of the interface (or some other value that uniquely identifies the service interface)
  2. The name of the method.
  3. The names of the parameter types the method expects.
  4. The args array.

The server side will have to:

  1. Find the implementation for that interface (the easiest way is to have some sort of map where the keys are the interface names and the values the implementation singleton instance)
  2. Find the method, using Class.getMethod( name, paramTypes );
  3. Execute the method by calling method.invoke(serviceObject, args); and send the return value back.
Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

Hi biziclop, when you mention the server executing the command using reflection, can you elaborate just a little more on this please? You answered a post yesterday on the command pattern for me and since then I've read up on dynamic proxies which are wicked powerful. I'm good for code thanks. I'm more interested in the overall concepts. Many thanks for your help
@Joeblackdev Updated my answer, hope it helps.
Hi biziclop - just to clarify: In the context of the FooService interface and FooServiceImpl concrete class that resides on the server. In the proxy that you outlined above, how will serviceObject be set? Will this be an instance of FooServiceImpl? If this is the case, I will need the 'FooServiceImpl' class on both the client and server, correct? Many thanks again for your help
@Joeblackdev No, you won't have the implementation on the client side. The sample code is for a local proxy, to demonstrate how invocation is done without the remote bit. In the remote scenario, you wouldn't have a serviceObject in your proxy, because you would only send the parameters to the server and wait for the response. On the server side you don't need a proxy, just a listener that executes the call with reflection in the way I described.
@Joeblackdev Here's a code smaple I created for you, because I see that I made a mistake with that service object: docs.google.com/…
|
2

You should look into protocol buffers from google: http://code.google.com/p/protobuf/

This library defines an IDL for generating struct like classes that can be written and read from a stream/byte array/etc. They also define an RPC mechanism using the defined messages.

I've used this library for a similar problem and it worked very well.

Improve this answer

1 Comment

No problem, and yep, The IDL you use to define your RPC messages generates POJO's. Java and C++ are both target languages.
0

RMI is the way to go.

Java RMI is a Java application programming interface that performs the object-oriented equivalent of remote procedure calls (RPC).

Improve this answer

1 Comment

Hi Klark, I can't use RMI here. The client platform (Android) doesn't facilitate the use of RMI.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.