Um eine LAN-Verbindung herzustellen, müssen Sie das Prinzip der Informationsübertragung kennen.
Die im LAN übertragenen Informationen liegen in Form von Paketen vor. Ich verwende TCP-Pakete, um Daten zu übertragen, und IP-Pakete sind in den TCP-Paketen eingekapselt.
Der folgende Satz besteht darin, die IP-Adresse eines Servers über eine statische IPV4-Protokollklasse abzurufen.
address = InetAddress.getByName("192.168.43.86"); hat die IP-Adresse des Servers in TCP erhalten, aber die IP-Adresse allein kann eine bestimmte Anwendung nicht sperren, daher wurde das Konzept von Sockets eingeführt. Die Portnummer wird verwendet, um den Prozess des Hosts zu sperren. Die Portnummer ist im Allgemeinen 1024 bis 49151, da 0 bis 1023 eine bekannte Portnummer ist und im Allgemeinen für einige gängige Ports wie HTTP verwendet wird. 49152 bis 65535 ist eine temporäre Portnummer, die nicht zufällig belegt werden kann während der Ausführung des Programms zugewiesen.
Socket = IP + Portnummer
Dieser Satz definiert einen Socket mit der Portnummer 9998 und der IP 192.168.43.86.
int port = 9998; socket = new Socket(address,port);
Aus der Perspektive von Java-Klassen abstrahieren Server und Client eine Verbindung über Socket-Verbindungen. Der Server realisiert die Informationslesefunktion, indem er einen eigenen Socket-Port einrichtet und überwacht, ob ein Client eine Verbindung zu diesem Port herstellt. Der Client überträgt Daten über die vom Server vereinbarte Portnummer an den Server. Führen Sie nach dem Einschalten des Servers den Client aus und führen Sie einen Drei-Wege-Handshake mit dem Server durch, um eine TCP-Verbindung herzustellen. Basierend auf dieser Verbindung wird dann die Kommunikation zwischen dem Client und dem Server realisiert.
Da der Server möglicherweise mehrere Objekte gleichzeitig bedient, warten bei Verwendung der herkömmlichen Methode für die Serververbindung mehrere Clients darauf, dass ein Client mit dem Server interagiert. Um dieses Problem zu lösen, wird ein Multithreading-Ansatz gewählt.
Verwenden Sie die SuperSocket-Klasse, um die Socket-Klasse zu erben und die Runnable-Schnittstelle zu implementieren, um einen Multithread-Betrieb zu erreichen.
class SuperSocket extends Socket implements Runnable
SuperSocket socket_1 = new SuperSocket(9999); SuperSocket socket_2 = new SuperSocket(9998); SuperSocket socket_3 = new SuperSocket(9997); Thread s1 = new Thread(socket_1); Thread s2 = new Thread(socket_2); Thread s3 = new Thread(socket_3);
Die Architektur des Servers wird im dritten Teil gezeigt und der Code wird wie folgt implementiert:
package TCP;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TCPserver2 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
//实例化具有多线程功能的服务器专用socket类
//需要传递端口号作为初始化变量
SuperSocket socket_1 = new SuperSocket(9996);
SuperSocket socket_2 = new SuperSocket(9998);
SuperSocket socket_3 = new SuperSocket(9997);
//建立三个子线程
Thread s1 = new Thread(socket_1);
Thread s2 = new Thread(socket_2);
Thread s3 = new Thread(socket_3);
try {
while(true) {
//开启线程
s1.start();
s2.start();
s3.start();
if(scan.next()=="123"){
//结束线程
break;
}
}
} finally {
try {
//关闭套接字
socket_1.close();
socket_2.close();
socket_3.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
class SuperSocket extends Socket implements Runnable{
InputStream is;
byte[] buffer;
Socket socket=null;
ServerSocket serverSocket=null;
public SuperSocket(int port){
try {
//初始服务器型套接字
serverSocket = new ServerSocket(port);
buffer = new byte[1024];
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
try {
//等待端口连接
socket = serverSocket.accept();
//连接完成后创建输入流
is = socket.getInputStream();
//读取客户端传送信息
int len = is.read(buffer);
String str = new String(buffer, 0, len);
System.out.println(str);
} catch (IOException e) {
e.printStackTrace();
}
}
}Client
Die Architektur des Clients wird im dritten Teil gezeigt und der Code wird implementiert wie folgt
package TCP;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
public class TCPclient {
public static void main(String[] args) {
InetAddress address=null;
Socket socket=null;
OutputStream os=null;
String message=null;
Scanner sca=null;
try {
//得到本机IP地址
address = InetAddress.getByName("192.168.43.86");
//规定端口号，建立套接字
int port = 9998;
socket = new Socket(address,port);
//绑定套接字的输出流
os = socket.getOutputStream();
sca = new Scanner(System.in);
while(true) {
message = sca.next();
//写入输出流，在局域网中传输
os.write(message.getBytes());
}
} catch (UnknownHostException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
}finally {
try {
//关闭端口号，关闭io流
os.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}Das obige ist der detaillierte Inhalt vonSo erstellen Sie einen Multithread-LAN-Chatroom in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
