Tutorial - Wie baue ich das WebSocket gedönse in meiner Version ein?
Schritt 1: Importieren der WebSocket Lib.
Diese wird genauso eingebunden wie der MySQL-Connector. Da das ganze relativ klar ist, brauche ich dazu auch nicht viel schreiben.
Download: https://github.com/hovida/BananaChat/blo…et.jar?raw=true
Schritt 2: Hinzufügen der Websocket.java
Diese wird einfach im Package "knuddels" abgelegt, genau da wo auch die Server.java vorhanden ist.
Download: https://raw.github.com/hovida/BananaChat…/Websocket.java
Schritt 3: Server.java abändern
Wegsocket importieren:
|
Java-Quelltext
|
1
|
import org.java_websocket.WebSocket;
|
Hier kommt folgende Methode hinzu:
|
|
Java-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
public Client getClient(WebSocket socket) {
synchronized (clients) {
for(Client client : clients.values()) {
if(client.hasWebsocket(socket)) {
return client;
}
}
}
return null;
}
public void removeClient(WebSocket socket) {
synchronized (clients) {
String name = "";
for(Client client : clients.values()) {
if(client.hasWebsocket(socket)) {
name = client.getName();
break;
}
}
clients.remove(name.toLowerCase());
}
}
|
Die Listener-Methode wird verändert (siehe Kommentare:
|
|
Java-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
private void listen(int port, int wss_port) { // <<<<< Neuer Parameter "wss_port"
try {
ServerSocket listener = new ServerSocket(port);
try {// <<<<<
new Websocket(wss_port).start();// <<<<<
} catch (Exception e) {// <<<<<
e.printStackTrace();// <<<<<
}// <<<<<
System.out.println(String.format("Listening on port %s (Websocket: %s)", port, wss_port));// <<<<< veränderte Ausgabe
while (true) {
Socket socket = listener.accept();
new SessionHandler(socket).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
|
Und die main-Methode wird auch verändert:
|
|
Java-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public static void main(String[] args) {
int port;
int wss_port; // <<<< Neue Variable
if (args.length > 0) {
port = Integer.parseInt(args[0]);
wss_port = Integer.parseInt(args[1]); // <<< Neues Argument
} else {
port = 2710; // default
wss_port = 2711; //<<<< Default WebSocket Port
}
instance.loadConfigs();
instance.listen(port, wss_port); // Parameter hinzugefügt
}
|
Schritt 4: Client.java abändern
Wieder WebSocket importieren:
|
|
Java-Quelltext
|
1
|
import org.java_websocket.WebSocket;
|
Neue Variable setzen:
|
|
Java-Quelltext
|
1
2
3
|
public class Client {
private WebSocket websocket;
//....
|
Konstruktor abändern:
|
|
Java-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public Client(Socket socket) {
channels = new ArrayList<Channel>();
this.socket = socket;
this.websocket = null; // <<< Neu
if (socket == null) {// <<< Neu
return;// <<< Neu
}// <<< Neu
try {
out = socket.getOutputStream();
} catch (IOException e) {
}
}
|
Neue Methode hinzufügen:
|
|
Java-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
public Client setToWebsocket(WebSocket socket) {
channels = new ArrayList<Channel>();
this.socket = null;
this.websocket = socket;
if(websocket == null) {
return null;
}
// temporary Name
this.name = String.format("WebSocket Client #%s", socket.getLocalSocketAddress().hashCode());
/*try {
out = websocket;
} catch (IOException e) {
}*/
return this;
}
public boolean hasWebsocket(WebSocket socket) {
if(socket != null && socket == this.websocket) {
return true;
}
return false;
}
|
send-Methode verändern:
|
|
Java-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public void send(String message) {
if (socket != null && socket.isConnected()) {
try {
out.write(Protocol.encode(Huffman.getEncoder().encode(message, 0)));
} catch (Exception e) {
e.printStackTrace();
}
}
// Send over WebSocket
if(websocket != null && websocket.isOpen()) { // << NEU
try { // << NEU
websocket.send(message); // << NEU
} catch (Exception e) { // << NEU
e.printStackTrace(); // << NEU
} // << NEU
} // << NEU
}
|
Schritt 4: SessionHandler.java abändern
Der Opcode-Handler wird in einer seperate Methode gesetzt, da diese nun mehrfach benötigt wird:
|
|
Java-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
public void read(Client client, String decoded) {
System.out.println("Receive: " + decoded);
String[] tokens = decoded.split("\0");
String opcode = tokens[0];
if (opcode.equals(ReceiveOpcode.EXCEPTION.getValue())) {
/* Do Nothing */
} else if (opcode.equals(ReceiveOpcode.DISCONNECT.getValue())) {
/* Do Nothing */
} else if (opcode.equals(ReceiveOpcode.CHAT.getValue())) {
ChatHandler.handle(tokens, client);
} else if (opcode.equals(ReceiveOpcode.PING.getValue())) {
PingHandler.handle(tokens, client);
} else if (opcode.equals(ReceiveOpcode.POLL.getValue())) {
PollHandler.handle(tokens, client);
} else if (opcode.equals(ReceiveOpcode.LINK_CLICKED.getValue())) {
/* Do Nothing */
} else if (opcode.equals(ReceiveOpcode.JOIN_CHANNEL.getValue())) {
JoinChannelHandler.handle(tokens, client);
} else if (opcode.equals(ReceiveOpcode.Q_TOKEN.getValue())) {
/* Do Nothing */
} else if (opcode.equals(ReceiveOpcode.REQUEST_USER_LIST.getValue())) {
/* Do Nothing */
} else if (opcode.equals(ReceiveOpcode.HANDSHAKE.getValue())) {
HandshakeHandler.handle(tokens, client);
} else if (opcode.equals(ReceiveOpcode.REQUEST_HELP.getValue())) {
RequestHelpHandler.handle(tokens, client);
} else if (opcode.equals(ReceiveOpcode.LEAVE_CHANNEL.getValue())) {
LeaveChannelHandler.handle(tokens, client);
} else if (opcode.equals(ReceiveOpcode.WHOIS.getValue())) {
/* Do Nothing */
} else {
System.out.println(String.format("Unhandled opcode: %s", opcode));
}
}
|
Run-Methode wird abgeändert:
|
|
Java-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
@Override
public void run() {
Client client = new Client(socket);
try {
InputStream in = socket.getInputStream();
byte type = (byte) in.read();
if (type == 0x00) {
while (true) {
byte[] buffer = Protocol.decode(in);
String decoded = Huffman.getDecoder().decode(buffer);
read(client, decoded); /// <<< Ist nun die "read-Methode"
}
} else if (type == 0x02) {
// registration
}
} catch (IOException e) {
/* Do Nothing */
} finally {
client.disconnect();
}
}
|
Das sollte es gewesen sein.
Zitat
Neuigkeiten »
Banana-Chat - eine WebSocket-Implementation
(4. Juni 2013, 15:13)
Donnerstag, 16. April 2026, 10:28
Zum Seitenanfang
