-
Notifications
You must be signed in to change notification settings - Fork 0
/
Client.java
161 lines (143 loc) · 4.72 KB
/
Client.java
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
/**
* <p>
* Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
* </p>
* <p>
* Klasse Client
* </p>
* <p>
* Objekte von Unterklassen der abstrakten Klasse Client ermoeglichen
* Netzwerkverbindungen zu einem Server mittels TCP/IP-Protokoll. Nach
* Verbindungsaufbau koennen Zeichenketten (Strings) zum Server gesendet und von
* diesem empfangen werden, wobei der Nachrichtenempfang nebenlaeufig geschieht.
* Zur Vereinfachung finden Nachrichtenversand und -empfang zeilenweise statt,
* d. h., beim Senden einer Zeichenkette wird ein Zeilentrenner ergaenzt und beim
* Empfang wird dieser entfernt. Jede empfangene Nachricht wird einer
* Ereignisbehandlungsmethode uebergeben, die in Unterklassen implementiert werden
* muss. Es findet nur eine rudimentaere Fehlerbehandlung statt, so dass z.B.
* Verbindungsabbrueche nicht zu einem Programmabbruch fuehren. Eine einmal
* unterbrochene oder getrennte Verbindung kann nicht reaktiviert werden.
* </p>
*
* @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
* @version 30.08.2016
*/
public abstract class Client
{
private MessageHandler messageHandler;
private class MessageHandler extends Thread
{
private SocketWrapper socketWrapper;
private boolean active;
private class SocketWrapper
{
private Socket socket;
private BufferedReader fromServer;
private PrintWriter toServer;
public SocketWrapper(String pServerIP, int pServerPort)
{
try
{
socket = new Socket(pServerIP, pServerPort);
toServer = new PrintWriter(socket.getOutputStream(), true);
fromServer = new BufferedReader(new InputStreamReader(socket.getInputStream()));
}
catch (IOException e)
{
socket = null;
toServer = null;
fromServer = null;
}
}
public String receive()
{
if(fromServer != null)
try
{
return fromServer.readLine();
}
catch (IOException e)
{
}
return(null);
}
public void send(String pMessage)
{
if(toServer != null)
{
toServer.println(pMessage);
}
}
public void close()
{
if(socket != null)
try
{
socket.close();
}
catch (IOException e)
{
/*
* Falls eine Verbindung getrennt werden soll, deren Endpunkt
* nicht mehr existiert bzw. ihrerseits bereits beendet worden ist,
* geschieht nichts.
*/
}
}
}
private MessageHandler(String pServerIP, int pServerPort)
{
socketWrapper = new SocketWrapper(pServerIP, pServerPort);
start();
if(socketWrapper.socket != null)
active = true;
}
public void run()
{
String message = null;
while (active)
{
message = socketWrapper.receive();
if (message != null)
processMessage(message);
else
close();
}
}
private void send(String pMessage)
{
if(active)
socketWrapper.send(pMessage);
}
private void close()
{
if(active)
{
active = false;
socketWrapper.close();
}
}
}
public Client(String pServerIP, int pServerPort)
{
messageHandler = new MessageHandler(pServerIP, pServerPort);
}
public boolean isConnected()
{
return(messageHandler.active);
}
public void send(String pMessage)
{
messageHandler.send(pMessage);
}
public void close()
{
messageHandler.close();
}
public abstract void processMessage(String pMessage);
}