ठीक है, इस तरह की चीजें बढ़ी और मैं निम्नलिखित दस वर्गों के साथ समाप्त हुआ ...
इस विधि में लब्बोलुआब यह है कि सभी संचार Messageवर्ग का उपयोग करते हुए होता है , अर्थात खेल कभी भी खिलाड़ियों के तरीकों को सीधे नहीं कहता है लेकिन हमेशा आपके ढांचे से संचारक वर्ग का उपयोग करता है। देशी जावा कक्षाओं के लिए एक प्रतिबिंब-आधारित संचारक है और फिर सभी गैर-जावा खिलाड़ियों के लिए एक कस्टम संचारक होना चाहिए। Message<Integer> message = new Message<>("say", Integer.class, "Hello");एक संदेश को शुरू करने के लिए एक sayपैरामीटर नाम के साथ संदेश को "Hello"लौटा सकता है a Integer। इसके बाद एक संचारक (खिलाड़ी प्रकार के आधार पर कारखाने का उपयोग करके उत्पन्न) को पारित किया जाता है, जो तब कमांड को निष्पादित करता है।
import java.util.Optional;
public class Game {
Player player; // In reality you'd have a list here
public Game() {
System.out.println("Game starts");
player = new PlayerOne();
}
public void play() {
Message<Boolean> message1 = new Message<>("x", Boolean.class, true, false, true);
Message<Integer> message2 = new Message<>("y", Integer.class, "Hello");
Result result1 = sendMessage(player, message1);
System.out.println("Response 1: " + result1.getResult());
Result result2 = sendMessage(player, message2);
System.out.println("Response 2: " + result2.getResult());
}
private Result sendMessage(Player player, Message<?> message1) {
return Optional.ofNullable(player)
.map(Game::createCommunicator)
.map(comm -> comm.executeCommand(message1))
.get();
}
public static void main(String[] args) {
Game game = new Game();
game.play();
}
private static PlayerCommunicator createCommunicator(Player player) {
if (player instanceof NativePlayer) {
return new NativePlayerCommunicator((NativePlayer) player);
}
return new ExternalPlayerCommunicator((ExternalPlayer) player);
}
}
public abstract class Player {}
public class ExternalPlayer extends Player {}
public abstract class NativePlayer extends Player {
abstract boolean x(Boolean a, Boolean b, Boolean c);
abstract Integer y(String yParam);
abstract Void z(Void zParam);
}
public abstract class PlayerCommunicator {
public abstract Result executeCommand(Message message);
}
import java.lang.reflect.Method;
public class NativePlayerCommunicator extends PlayerCommunicator {
private NativePlayer player;
public NativePlayerCommunicator(NativePlayer player) { this.player = player; }
public Result executeCommand(Message message) {
try {
Method method = player.getClass().getDeclaredMethod(message.getMethod(), message.getParamTypes());
return new Result(method.invoke(player, message.getArguments()));
} catch (Exception e) { throw new RuntimeException(e); }
}
}
public class ExternalPlayerCommunicator extends PlayerCommunicator {
private ExternalPlayer player;
public ExternalPlayerCommunicator(ExternalPlayer player) { this.player = player; }
@Override
public Result executeCommand(Message message) { /* Do some IO stuff */ return null; }
}
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Message<OUT> {
private final String method;
private final Class<OUT> returnType;
private final Object[] arguments;
public Message(final String method, final Class<OUT> returnType, final Object... arguments) {
this.method = method;
this.returnType = returnType;
this.arguments = arguments;
}
public String getMethod() { return method; }
public Class<OUT> getReturnType() { return returnType; }
public Object[] getArguments() { return arguments; }
public Class[] getParamTypes() {
List<Class> classes = Arrays.stream(arguments).map(Object::getClass).collect(Collectors.toList());
Class[] classArray = Arrays.copyOf(classes.toArray(), classes.size(), Class[].class);
return classArray;
}
}
public class PlayerOne extends NativePlayer {
@Override
boolean x(Boolean a, Boolean b, Boolean c) {
System.out.println(String.format("x called: %b %b %b", a, b, c));
return a || b || c;
}
@Override
Integer y(String yParam) {
System.out.println("y called: " + yParam);
return yParam.length();
}
@Override
Void z(Void zParam) {
System.out.println("z called");
return null;
}
}
public class Result {
private final Object result;
public Result(Object result) { this.result = result; }
public Object getResult() { return result; }
}
(PS। मेरे मन में अन्य कीवर्ड जो मैं अभी कुछ भी उपयोगी नहीं बता सकते हैं: कमांड पैटर्न , विज़िटर पैटर्न , java.lang.reflect.ParameterizedType )
PlayerComm extends Player" -पार्ट के बारे में उलझन में हूँ । क्या सभी जावा प्रवेशकों का विस्तार हो रहा हैPlayer, और यहPlayerCommवर्ग गैर-जावा प्रवेशकों के लिए एक एडेप्टर है?