Utilisation de sockets pour envoyer et recevoir des données
J'utilise des sockets pour connecter mon Android (client) et un serveur backend Java). À partir du client, je voudrais envoyer deux variables de données à chaque fois Je communique avec le serveur.
1) Une sorte de message (défini par l'utilisateur via l'interface)
2) La langue du message (définie par l'utilisateur via l'interface)
Comment pourrais-je les envoyer pour que le serveur interprète chacun comme une entité distincte?
Après avoir lu les données côté serveur et tiré une conclusion appropriée, je voudrais retourner un seul message au client. (Je pense que je serai d'accord avec ça)
Donc, mes deux questions sont de savoir comment puis-je établir que les deux chaînes envoyées (client à serveur) sont uniques du côté client et comment puis-je séparer ces deux chaînes du côté serveur. (Je pensais à un éventail de chaînes, mais je n'ai pas pu établir si cela était possible ou approprié.)
J'allais poster du code mais je ne sais pas comment cela pourrait aider.
Je suppose que vous utilisez TCP sockets pour l'interaction client-serveur? Une façon d'envoyer différents types de données au serveur et de pouvoir faire la différence entre les deux est de dédier le premier octet (ou plus si vous avez plus de 256 types de messages) comme une sorte d'identifiant. Si le premier octet est un, alors c'est le message A, si c'est 2, puis son message B. Une façon simple d'envoyer cela via le socket est d'utiliser DataOutputStream/DataInputStream:
Client:
Socket socket = ...; // Create and connect the socket
DataOutputStream dOut = new DataOutputStream(socket.getOutputStream());
// Send first message
dOut.writeByte(1);
dOut.writeUTF("This is the first type of message.");
dOut.flush(); // Send off the data
// Send the second message
dOut.writeByte(2);
dOut.writeUTF("This is the second type of message.");
dOut.flush(); // Send off the data
// Send the third message
dOut.writeByte(3);
dOut.writeUTF("This is the third type of message (Part 1).");
dOut.writeUTF("This is the third type of message (Part 2).");
dOut.flush(); // Send off the data
// Send the exit message
dOut.writeByte(-1);
dOut.flush();
dOut.close();
Serveur:
Socket socket = ... // Set up receive socket
DataInputStream dIn = new DataInputStream(socket.getInputStream());
boolean done = false;
while(!done) {
byte messageType = dIn.readByte();
switch(messageType)
{
case 1: // Type A
System.out.println("Message A: " + dIn.readUTF());
break;
case 2: // Type B
System.out.println("Message B: " + dIn.readUTF());
break;
case 3: // Type C
System.out.println("Message C [1]: " + dIn.readUTF());
System.out.println("Message C [2]: " + dIn.readUTF());
break;
default:
done = true;
}
}
dIn.close();
Évidemment, vous pouvez envoyer toutes sortes de données, pas seulement des octets et des chaînes (UTF).
Notez que writeUTF écrit un format UTF-8 modifié, précédé d'un indicateur de longueur d'un entier codé sur deux octets non signé vous donnant 2^16 - 1 = 65535 octets à envoyer. Cela permet à readUTF de trouver la fin de la chaîne encodée. Si vous décidez de votre propre structure d'enregistrement, vous devez vous assurer que la fin et le type de l'enregistrement sont connus ou détectables.
la façon la plus simple de le faire est d'envelopper vos sockets dans ObjectInput/OutputStreams et d'envoyer des objets sérialisés Java. Vous pouvez créer des classes qui contiennent les données pertinentes, puis vous n'avez pas à vous soucier de les moindres détails de la gestion des protocoles binaires. Assurez-vous simplement de vider vos flux d'objets après avoir écrit chaque "message" d'objet.
//Client
import Java.io.*;
import Java.net.*;
public class Client {
public static void main(String[] args) {
String hostname = "localhost";
int port = 6789;
// declaration section:
// clientSocket: our client socket
// os: output stream
// is: input stream
Socket clientSocket = null;
DataOutputStream os = null;
BufferedReader is = null;
// Initialization section:
// Try to open a socket on the given port
// Try to open input and output streams
try {
clientSocket = new Socket(hostname, port);
os = new DataOutputStream(clientSocket.getOutputStream());
is = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
} catch (UnknownHostException e) {
System.err.println("Don't know about Host: " + hostname);
} catch (IOException e) {
System.err.println("Couldn't get I/O for the connection to: " + hostname);
}
// If everything has been initialized then we want to write some data
// to the socket we have opened a connection to on the given port
if (clientSocket == null || os == null || is == null) {
System.err.println( "Something is wrong. One variable is null." );
return;
}
try {
while ( true ) {
System.out.print( "Enter an integer (0 to stop connection, -1 to stop server): " );
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String keyboardInput = br.readLine();
os.writeBytes( keyboardInput + "\n" );
int n = Integer.parseInt( keyboardInput );
if ( n == 0 || n == -1 ) {
break;
}
String responseLine = is.readLine();
System.out.println("Server returns its square as: " + responseLine);
}
// clean up:
// close the output stream
// close the input stream
// close the socket
os.close();
is.close();
clientSocket.close();
} catch (UnknownHostException e) {
System.err.println("Trying to connect to unknown Host: " + e);
} catch (IOException e) {
System.err.println("IOException: " + e);
}
}
}
//Server
import Java.io.*;
import Java.net.*;
public class Server1 {
public static void main(String args[]) {
int port = 6789;
Server1 server = new Server1( port );
server.startServer();
}
// declare a server socket and a client socket for the server
ServerSocket echoServer = null;
Socket clientSocket = null;
int port;
public Server1( int port ) {
this.port = port;
}
public void stopServer() {
System.out.println( "Server cleaning up." );
System.exit(0);
}
public void startServer() {
// Try to open a server socket on the given port
// Note that we can't choose a port less than 1024 if we are not
// privileged users (root)
try {
echoServer = new ServerSocket(port);
}
catch (IOException e) {
System.out.println(e);
}
System.out.println( "Waiting for connections. Only one connection is allowed." );
// Create a socket object from the ServerSocket to listen and accept connections.
// Use Server1Connection to process the connection.
while ( true ) {
try {
clientSocket = echoServer.accept();
Server1Connection oneconnection = new Server1Connection(clientSocket, this);
oneconnection.run();
}
catch (IOException e) {
System.out.println(e);
}
}
}
}
class Server1Connection {
BufferedReader is;
PrintStream os;
Socket clientSocket;
Server1 server;
public Server1Connection(Socket clientSocket, Server1 server) {
this.clientSocket = clientSocket;
this.server = server;
System.out.println( "Connection established with: " + clientSocket );
try {
is = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
os = new PrintStream(clientSocket.getOutputStream());
} catch (IOException e) {
System.out.println(e);
}
}
public void run() {
String line;
try {
boolean serverStop = false;
while (true) {
line = is.readLine();
System.out.println( "Received " + line );
int n = Integer.parseInt(line);
if ( n == -1 ) {
serverStop = true;
break;
}
if ( n == 0 ) break;
os.println("" + n*n );
}
System.out.println( "Connection closed." );
is.close();
os.close();
clientSocket.close();
if ( serverStop ) server.stopServer();
} catch (IOException e) {
System.out.println(e);
}
}
}