Come gestire gli RPC nel gioco PlayN client-server?

Question

Mi piacerebbe utilizzare PlayN per creare un gioco di carte client/server, ad es. Cuori. Mentre mi concentro principalmente sull'output HTML5, preferirei essere indipendente dalla piattaforma di uscita nel caso in cui decida di creare un client Android in futuro. Come dovrei avvicinarmi al meccanismo RPC?

Queste sono le opzioni che ho pensato di:

1. Usa JSON per RPC con get()/post() Metodi - scrivere un servlet che accetta/restituisce JSON, e fare tutte le versioni del codice del client usa quello Sembra fattibile, ma sono preoccupato per la verbosità di JSON. Una volta ottenuto il lavoro di Hearts mi piacerebbe passare a giochi più complessi, e sono preoccupato che JSON comporterà molti messaggi molto più grandi del necessario che vengono passati avanti e indietro tra client e server. In realtà non so come lavorare con JSON in Java, ma presumo che sia fattibile. Le mie ipotesi sono in linea? Quanto funziona Java con JSON?
2. Continuare a utilizzare GWT-RPC. Posso farlo prendendo un'interfaccia di servizio asincrona nel mio costruttore core (indipendente dalla piattaforma) e nel mio HTML main() passo all'interfaccia GWT Async generata da GWT.create(MyService.class) (o almeno un wrapper attorno ad esso). Non ho idea di quanto bene funzionerebbe per le versioni non HTML. Posso utilizzare GWT-RPC direttamente dal codice Java lato client?
3. Utilizzare un'altra forma di RPC. Eventuali suggerimenti?

Answer 1

Per la RPC GWT sulle piattaforme Java e Android, attualmente sto sperimentando con l'utilizzo di GWT-syncproxy per fornire l'accesso client Java per i metodi di GWT RPC, e sto usando Guice, Gin, e RoboGuice su le rispettive piattaforme di destinazione per iniettare le istanze del servizio asincrono appropriate per l'oggetto Game istanziato.

Nel nucleo/pom.xml per un progetto visualizzarloN, che includono i seguenti dipendenza coordinate per sostenere DI Gin/Guice/RoboGuice come necessario:

<dependency> 
    <groupId>javax.inject</groupId> 
    <artifactId>javax.inject</artifactId> 
    <version>1</version> 
</dependency> 

Poi aggiungere annotazioni @Inject nessun campo all'interno della realizzazione concreta di gioco:

public class TestGame implements Game { 

    @Inject 
    TestServiceAsync _testService; 

    ... 

} 

nel codice HTML/pom.xml, includo coordina la dipendenza per Gin:

<dependency> 
    <groupId>com.google.gwt.inject</groupId> 
    <artifactId>gin</artifactId> 
    <version>1.5.0</version> 
</dependency> 

E creo TestGameGinjector e TestGameModule classi:

TestGameGinjector.java

@GinModules(TestGameModule.class) 
public interface TestGameGinjector extends Ginjector { 
    TestGame getGame(); 
} 

TestGameModule.java

public class TestGameModule extends AbstractGinModule { 
    @Override 
    protected void configure() { 
    } 
} 

Poiché in questo momento, sto solo iniettare il Interfaccia TestServiceAsync, non ho bisogno di mettere alcuna implementazione nel metodo TestGameModule.configure(); Gin gestisce l'istanza di AsyncServices per me tramite GWT.create().

Ho poi aggiunto il testo seguente TestGame.gwt.xml

<inherits name='com.google.gwt.inject.Inject'/> 

E, infine, ho apportato le seguenti modifiche al TestGameHtml.java

public class TestGameHtml extends HtmlGame { 

    private final TestGameGinjector _injector = GWT.create(TestGameGinjector.class); 

    @Override 
    public void start() { 
     HtmlPlatform platform = HtmlPlatform.register(); 
     platform.assetManager().setPathPrefix("test/"); 
     PlayN.run(_injector.getGame()); 
    } 
} 

E questo copre praticamente la piattaforma HTML5 per visualizzarloN.

per la piattaforma Java, aggiungo il seguente dipendenza coordinate per java/pom.xml:

<dependency> 
    <groupId>com.gdevelop.gwt.syncrpc</groupId> 
    <artifactId>gwt-syncproxy</artifactId> 
    <version>0.4-SNAPSHOT</version> 
</dependency> 

<dependency> 
    <groupId>com.google.inject</groupId> 
    <artifactId>guice</artifactId> 
    <version>3.0-rc2</version> 
</dependency> 

notano che il progetto GWT-syncproxy su Google Code non contiene un pom.xml. Ho una versione di gwt-syncproxy forked e disponibile tramite git a https://bitbucket.org/hatboyzero/gwt-syncproxy.git. Dovresti essere in grado di clonarlo, eseguire mvn clean package install per scaricarlo nel tuo repository Maven locale.

In ogni modo, ho creato un TestGameModule.java per la piattaforma Java come segue:

public class TestGameModule extends AbstractModule { 

    @Override 
    protected void configure() { 
     bind(TestServiceAsync.class).toProvider(TestServiceProvider.class); 
    } 

    public static class TestServiceProvider implements Provider<TestServiceAsync> { 
     public TestServiceAsync get() { 
      return (TestServiceAsync) SyncProxy.newProxyInstance(
       TestServiceAsync.class, 
       Deployment.gwtWebPath(), // URL to webapp -- http://127.0.0.1:8888/testgame 
       "test" 
      ); 
     } 
    } 
} 

E ho modificato TestGameJava.java come segue:

public class TestGameJava { 

    public static void main(String[] args) { 
     Injector _injector = Guice.createInjector(new TestGameModule()); 

     JavaPlatform platform = JavaPlatform.register(); 
     platform.assetManager().setPathPrefix("test/images"); 
     PlayN.run(_injector.getInstance(TestGame.class)); 
    } 
} 

ho attraversato un esercizio simile con la Piattaforma Android e RoboGuice - senza entrare nel dettaglio, le modifiche/snippet rilevanti sono le seguenti:

pom.xml d ependencies

<dependency> 
    <groupId>com.gdevelop.gwt.syncrpc</groupId> 
    <artifactId>gwt-syncproxy</artifactId> 
    <version>0.4-SNAPSHOT</version> 
</dependency> 

<dependency> 
    <groupId>org.roboguice</groupId> 
    <artifactId>roboguice</artifactId> 
    <version>1.1.2</version> 
</dependency> 

<dependency> 
    <groupId>com.google.inject</groupId> 
    <artifactId>guice</artifactId> 
    <version>3.0-rc2</version> 
    <classifier>no_aop</classifier> 
</dependency> 

TestGameApplication.java

public class TestGameApplication extends RoboApplication { 
    @Override 
    protected void addApplicationModules(List<Module> modules) { 
     modules.add(new TestGameModule()); 
    } 
} 

TestGameModule.java

public class TestGameModule extends AbstractModule { 

    @Override 
    protected void configure() { 
     bind(TestServiceAsync.class).toProvider(TestServiceProvider.class); 
    } 

    public static class TestServiceProvider implements Provider<TestServiceAsync> { 
     public TestServiceAsync get() { 
      return (TestServiceAsync) SyncProxy.newProxyInstance(
       TestServiceAsync.class, 
       Deployment.gwtWebPath(), // URL to webapp -- http://127.0.0.1:8888/testgame 
       "test" 
      ); 
     } 
    } 
} 

TestGameActivity.java

Questa è una sintesi rapida e sporca di come ho fatto funzionare Gin/Guice/RoboGuice + GWT nel mio progetto, e ho verificato che funzioni su entrambe le piattaforme Java e HTML in modo bello.

Ad ogni modo, c'è l'approccio GWT per fornire chiamate RPC a più piattaforme PlayN :).