2024-05-21 16:10:23
IP地址操作(IDEA)
1. 根据`InetAddress`包中的`get+ | LocalHost | ByName | 获取Host对象
2. 通过对InetAddress获得的对象调用下面的函数进行进一步对ip的操作
UDP通信
java.net.DatagramSocket 类实现UDP
- 通过创建对象以此来调用对象下面的函数
-sent(放Packet对象)
函数
-receive(放Packet对象)
函数- Socket中一般在接受数据需要端口发送数据端口由Packet定义
java.net.DatagramPacket类来接受数据
- 通过创建对象以此来调用对象下面的函数
- Packet中的port定义用于发送数据需要端口接受数据会自动定义端口
数据处理流程(UDP)(按照数字顺序)
客户端通过Socket定义端口
通过定义Pocket中的端口来指定数据发送到哪个端口的Socket中
代码实现
>点击查看代码<
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25public static void main(String[] args) throws
IOException
{
System.out.println("请输入---stop---来停止转发");
while (true) {
Scanner in = new Scanner(System.in);
String input = in.nextLine();
boolean stop = input.equals("stop");
byte[] bytes =
input.getBytes(StandardCharsets.UTF_8);
DatagramSocket list = new DatagramSocket();
InetAddress localHost = InetAddress.getLocalHost();
DatagramPacket packet = new
DatagramPacket(bytes,bytes.length,localHost,1234);
list.send(packet);
if (stop)
{
list.close();
break;
}
else {};
}
}
</details>
服务端通过Socket定义端口
对传进来的Pocket进行相关操作
代码实现
>点击查看代码<
1
2
3
4
5
6
7
8
9
10
11
12public static void main(String[] args) throws IOException {
DatagramSocket takeIn = new DatagramSocket(1234);
byte[] From1234 = new byte[1024 * 64];
DatagramPacket getSourceFrom1234 = new DatagramPacket(From1234, From1234.length);
while (true) {
takeIn.receive(getSourceFrom1234);
String rc = new String(From1234, 0, From1234.length);
System.out.println(rc);
}
}
</details>
TCP 通信
通过java.net.Socket来实现TCP(客户端)
- 通过创建对象来调用对象的函数
通过java.net.ServerSocket来实现TCP(服务端)
- 通过创建对象来调用对象的函数
通过java.io流来发送数据
- 把io流发送给Socket管道
数据处理流程(TCP)(按照数字顺序)
客户端通过Socket定义端口
定义OutpuStream输出流绑定到Socket管道
定义DataOutputStream帮到到OutputStream
写入数据
关闭
代码实现
>点击查看代码<
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
27public static void main(String[] args) throws IOException {
System.out.println("请输入----stop----来停止程序");
//地址对象
InetAddress address= InetAddress.getLocalHost();
//定义Socket
Socket socket = new Socket(address.getHostAddress(),1234);
//输出流
OutputStream output = socket.getOutputStream();
//高级输出流
DataOutputStream dataOutput = new DataOutputStream(output);
Scanner in = new Scanner(System.in);
while (true) {
String input = in.nextLine();
//写入
dataOutput.writeUTF(input);
// dataOutput.flush();
//关闭
if (input.equals("stop")){
System.out.println("退出程序");
dataOutput.close();
socket.close();
break;
}
}
}
</details>
服务端通过ServerSocket定义端口
接受Socket对象
读取Socket中的InputStream流
把InputStream流输出到DataInputStream流中
读取数据
关闭
代码实现
>点击查看代码<
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19public static void main(String[] args) throws IOException {
ServerSocket socket = new ServerSocket(1234);
Socket accept = socket.accept();
InputStream inputStream = accept.getInputStream();
DataInputStream dataInputStream = new DataInputStream(inputStream);
while (true) {
try {
String s = dataInputStream.readUTF();
System.out.println(s);
} catch (IOException e) {
System.out.println("服务端离线了");
socket.close();
inputStream.close();
dataInputStream.close();
break;
}
}
}
</details>
用多线程实现多发多收
客户端(clint)
- 主线程(发送数据)
- 代码实现
>点击查看代码<
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
33import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class Clint {
public static void main(String[] args) throws IOException {
System.out.println("请输入----stop----来停止程序");
//地址对象
InetAddress address= InetAddress.getLocalHost();
//定义Socket
Socket socket = new Socket(address.getHostAddress(),1234);
new clintReadThread(socket).start();
//输出流
OutputStream output = socket.getOutputStream();
//高级输出流
DataOutputStream dataOutput = new DataOutputStream(output);
Scanner in = new Scanner(System.in);
while (true) {
String input = in.nextLine();
//写入
// dataOutput.flush();
//关闭
if (input.equals("stop")){
System.out.println("退出程序");
dataOutput.close();
socket.close();
break;
}
dataOutput.writeUTF(input);
}
}
}
- 子线程(读取服务端传回的数据)
代码实现
>点击查看代码<
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
27import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
public class clintReadThread extends Thread{
private Socket socket;
public clintReadThread(Socket socket){
this.socket=socket;
}
public void run() {
while (true) {
try {
InputStream os = socket.getInputStream();
DataInputStream inputStream = new DataInputStream(os);
String s = inputStream.readUTF();
System.out.println("来自"+ socket.getRemoteSocketAddress()+"的消息"+s);
} catch (IOException e) {
System.out.println("收数据出错了");
break;
}
}
}
}
</details>
- 子线程(读取服务端传回的数据)
服务端(Server)
- 主线程(接收数据)
代码实现
>点击查看代码<
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Server {
static List<Socket> clints = new ArrayList<>();
public static void main(String[] args) throws IOException {
ServerSocket socket = new ServerSocket(1234);
while (true) {
Socket accept = socket.accept();
clints.add(accept);
System.out.println("有人上线" + accept.getRemoteSocketAddress());
new ServerReadTherad(accept).start();
}
}}
</details>
- 子线程(发送接收到的数据到客户端)
代码实现
>点击查看代码<
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
39import java.io.*;
import java.net.Socket;
public class ServerReadTherad extends Thread{
private Socket socket;
public ServerReadTherad(Socket socket){
this.socket = socket;
}
public void run(){
try {
InputStream inputStream = socket.getInputStream();
DataInputStream dataInputStream = new DataInputStream(inputStream);
while (true) {
try {
String s = dataInputStream.readUTF();
sentMsgToAllClints(s);
System.out.println(s);
} catch (Exception e) {
System.out.println("有人伏地 我手拿利器"+socket.getRemoteSocketAddress());
Server.clints.remove(socket);
inputStream.close();
dataInputStream.close();
socket.close();
break;
}
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private void sentMsgToAllClints(String s) throws IOException {
for (Socket clint : Server.clints) {
OutputStream os = clint.getOutputStream();
DataOutputStream outData = new DataOutputStream(os);
outData.writeUTF(s);
}
}
}
- 主线程(接收数据)
BS架构的线程池优化
- 服务端
代码示例
>点击查看代码<
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25package bstest;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.sql.Time;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Server {
public static void main(String[] args) throws IOException {
System.out.println("服务端启动");
ServerSocket socket = new ServerSocket(1234);
ThreadPoolExecutor pool = new ThreadPoolExecutor(20 * 2, 20 * 2, 0, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(8),
new ThreadPoolExecutor.AbortPolicy()
);
while (true) {
Socket accept = socket.accept();
pool.execute( new ServerThroad(accept));
}
}
}消息队列
- 代码实现
>点击查看代码<
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
29package bstest;
import java.io.*;
import java.net.Socket;
public class ServerThroad extends Thread{
private Socket socket;
public ServerThroad(Socket socket){
this.socket = socket;
}
public void run() {
try {
OutputStream outputStream = socket.getOutputStream();
PrintStream printStream = new PrintStream(outputStream);
System.out.println(socket.getRemoteSocketAddress());
printStream.println("HTTP/1.1 200 ok");
printStream.println("Content-Type:text/html;charset=UTF-8");
printStream.println();
printStream.println("<div style='color : skyblue'>你妈的好麻烦</div>");
outputStream.close();
printStream.close();
socket.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
- 代码实现