Posilam me kody.
Strana klienta:
- vzdy vytvori novou instaci, MySocketClient(host, port)
- posle packet na server, funkce: writeObject(packet)
a ceka na prijem packetu ze serveru, funkce readObject()
- kdyz prijme data od serveru, tak je posle na USB, viz funkce :
sendPacket(sendPacket)
Strana serveru:
- za zacatku vytvori instanci serveru, MySocketServer(port, this)
- a pak vzdt ceka na accept, po acceptu se spusti vlakno pro prijem a
odeslani packetu
// cast Main
if (typeRemoteAccess == RemoteAccess.TYPE_CLIENT) {
String host = RemoteAccess.getHost();
int port = RemoteAccess.getPort();
m_mySocketClient = new MySocketClient(host, port);
m_mySocketClient.connect();
m_mySocketClient.writeObject(packet);
DCPPacket sendPacket = m_mySocketClient.readObject();
if (sendPacket != null) {
try {
sendPacket(sendPacket);
} catch (Exception e) {}
System.out.println("Od Server send : " + packet.m_address);
}
}
else if (typeRemoteAccess == RemoteAccess.TYPE_SERVER) {
if (mySocketServer == null) m_mySocketServer = new
MySocketServer(port, this);
m_mySocketServer.listenClient(packet);
}
// MySocketServer.java
public class MySocketServer {
private DCPServer m_dcpServer;
private ServerSocket m_serverSocket;
private Connect m_connect;
private Boolean m_acceptStatus = Boolean.FALSE;
public MySocketServer(int port, DCPServer dcpServer) {
m_dcpServer = dcpServer;
try {
m_serverSocket = new ServerSocket(port);
} catch (Exception e) {
//e.printStackTrace();
}
System.out.println("Server posloucha na portu: " + port);
}
public void listenClient(DCPPacket packet) {
try {
System.out.println("Ceka na pripojeni.");
Socket client = m_serverSocket.accept();
System.out.println("Akceptovane pripojeni z: " +
client.getInetAddress());
m_connect = new Connect(client, packet, m_dcpServer);
m_connect.start();
} catch(Exception e) {
close();
}
}
private void close() {
try {
m_serverSocket.close();
} catch(Exception ex) {
System.err.println("Chyba pri zavirani accept server: " +
ex.getMessage());
}
}
}
class Connect extends Thread {
private DCPServer m_dcpServer;
private DCPPacket m_packet;
private Socket m_client = null;
private ObjectInputStream m_objectIn = null;
private ObjectOutputStream m_objectOut = null;
private boolean m_receiveStatus = false;
public Connect(Socket clientSocket, DCPPacket packet, DCPServer
dcpServer) {
m_dcpServer = dcpServer;
m_client = clientSocket;
m_packet = packet;
try {
// otevreni I/O streamu
m_objectIn = new ObjectInputStream(m_client.getInputStream());
m_objectOut = new
ObjectOutputStream(m_client.getOutputStream());
} catch(Exception e) {
try {
m_client.close();
} catch (Exception ex) {
System.out.println(ex.getMessage());
}
return;
}
}
public void run() {
// poslani packetu klientovi
writePacket(m_packet);
// cteni packetu od klienta
readPacket();
// zavreni spojeni
close();
}
private void writePacket(DCPPacket packet) {
try {
// poslani objektu zpet klientovi
m_objectOut.writeObject(packet);
m_objectOut.flush();
System.out.println("Poslan packet klinetovi.");
} catch (Exception e) {
close();
System.err.println("Chyba pri zapisu packetu do klient!");
}
}
private void readPacket() {
try {
// cteni objektu
DCPPacket packet = (DCPPacket) m_objectIn.readObject();
System.out.println("Od client read: " + packet.m_address);
m_dcpServer.notifyPacket(packet);
} catch (Exception e) {
close();
System.err.println("Chyba pri cteni packetu z klienta!");
}
}
private void close() {
try {
// zavreni pripojeni
m_objectIn.close();
m_objectOut.close();
m_client.close();
} catch (Exception e) {
System.err.println("Chyba pri zavirani objektu na strane
serveru!");
}
}
}
// MySocketClient.java
public class MySocketClient {
private String m_host;
private int m_port;
private Socket m_socket = null;
private ObjectOutputStream m_out = null;
private ObjectInputStream m_in = null;
public MySocketClient(String host, int port) {
m_host = host;
m_port = port;
}
public void connect() {
try {
m_socket = new Socket(m_host, m_port);
m_out = new ObjectOutputStream(m_socket.getOutputStream());
m_in = new ObjectInputStream(m_socket.getInputStream());
System.err.println("Pripojeno k host: " + m_host);
} catch (UnknownHostException e) {
System.err.println("Neznamy host: " + m_host);
} catch (IOException e) {
System.err.println("Nemuzu se pripojit k: " + m_host);
}
}
public void writeObject(DCPPacket packet) {
try {
m_out.writeObject(packet);
m_out.flush();
System.out.println("Odeslan packet na server.");
} catch (IOException e) {
System.err.println("Chyba pri zapisu packetu na server!");
} catch (NullPointerException e) {}
}
public DCPPacket readObject() {
DCPPacket packet = null;
try {
packet = (DCPPacket) m_in.readObject();
System.out.println("Precten packet ze serveru.");
return packet;
} catch (IOException e) {
System.err.println("Chyba pri cteni packetu ze serveru!");
return null;
} catch (ClassNotFoundException e) {
System.err.println("Chyba trida nenalezena!");
return null;
} catch (NullPointerException e) {
return null;
}
}
public void close() {
try {
m_out.close();
m_in.close();
} catch (Exception e) {}
}
}
Martin Kuba napsal(a):
Martin Jedlička napsal(a):
Nene, potrebuju prenest data prectene na jednom PC z USB na jiny PC a
zpet.
Presneji receno: Na serveru (PC2) budu posilat packety klientovi
(PC1) pres TCP, klient posle packet na USB a odpoved z USB posle zpet
pres TCP serveru...
Proc RMI?
Pri pouziti socketu mam problem v tom, ze kdyz posle server packet
klientovi, tak server ocekava odpoved od klienta... pokud ale klient
neodpovi, tak server "vytuhne" na funkci accept.
Myslel jsem, ze problem s cekanim na accept na strane serveru obejdu
pouzitim RMI, navic RMI je trosku vyhodnejsi na implementaci.
Tak to nei, accept() je pro prijmuti spojeni na serverovem socketu,
a vrati jiny socket, ktery je ekvivalentni tomu klientskemu.
Tj. po navazani spojeni jsou si uz klient a server rovny,
lisi se jenom pred navazani spojeni tim, ze server ceka na znamem portu
a klient spojeni iniciuje.
Makub
