Al lavoro abbiamo un backend java che parla con Python su alcuni dispositivi mobili. I dispositivi mobili non hanno GUI, è solo pura manipolazione delle stringhe. Tutti i contatti sono iniziati dal pitone; il java è solo per ascoltare e rispondere.
Come tale il python invierà messaggi come:
message_name(field1, field2, field 3)
Come stringhe. Il listener quindi lo preleva, trova la classe associata per message_name (che è definita in un file XML) e le alimenta con i campi. La classe invia quindi all'ascoltatore una risposta che è solo un csv così:
response_field1, response_field2, response_field3
Non ho molta familiarità con questo tipo di interfaccia (o con qualsiasi interfaccia client-server), ma sono abbastanza sicuro che non si tratti di REST o SOAP. Non sono sicuro che abbia persino un nome o che sia semplicemente un tipo di cosa nostrana. Nessuno dei miei colleghi ha un nome per questo.
In risposta al commento di @moberemk, il file XML ha un aspetto simile a questo (per il messaggio / risposta precedente):
<bean id="command_name" parent="base_request_class"
class="the_class_that_takes_the_request"
scope="prototype">
<property name="readOnly" value="true"/>
<property name="commandName" value="message_name" />
<property name="response" ref="name_of_response_bean" />
<property name="args">
<list>
<value>field1</value>
<value>field2</value>
<value>field3</value>
</list>
</property>
</bean>
<bean id="name_of_response_bean"
class="base_response_class
scope="prototype">
<property name="fields">
<list>
<value>response_field1</value>
<value>response_field2</value>
<value>response_field3</value>
</list>
</property>
</bean>
L'ascoltatore prende nota di questo file XML. Quindi, dopo aver ricevuto un messaggio, cerca un bean rilevante con "commandName"="message_name" per qualunque cosa "message_name" abbia attraversato. Quindi alimenta i campi nell'elenco dei campi (arg) alla classe (data dalla proprietà del bean "class"). Quindi il listener, una volta che il thread per la classe che accetta la richiesta è terminato, prende il risultato di ritorno di quella classe e lo invia letteralmente al dispositivo python.
Quindi, se l'ascoltatore fosse un umano, il processo andrebbe qualcosa come:
<receives message>
<looks at message name>
"Oh, it's a $message_name type of message. I know where to find who can help"
<Looks up who handles that kind of message>
<sends him the message with note "Let me know what you get back!">
<Guy that handles that message does his message handling, tells the listener what he found>
<Listener returns that to the device>
Con qualche pseudocodice python ...
def listener(self, cmd):
parsed = []
parsed = self.parse(cmd) #Array with ["name", "field1", "field2" ...]
class = self.find_matching_class(parsed[0]) #looks through the XML for the name of the class that should handle this message. String type
executor = getattr(sys.modules[__name__], class) #Gets an instance of the class related to the message
response = executor.execute(response[1:])
self.connection.sendall(response) #Sends the response created by the 'executor' class back to the device that asked for it