测试方向基础-网络编程

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量544 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64360878/article/details/123646233
版权

文章目录

网络编程

计算机网络：通过一定的物理设备将处于不同位置的计算机连接起来组成的网络。

网络编程：在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wfOkFE1U-1647868064146)(C:\Users\yyc\AppData\Roaming\Typora\typora-user-images\image-20220321185708421.png)]

IP地址、域名、端口、URL

  • IP地址：为了准确地定位网络上的目标主机，网络中的每个设备都会有一个唯一的数字表示，即网络的IP地址。

    static InetAddress getByName(String host):host) 确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址.

    public class InetAddressDemo {
public static void main(String[] args) throws UnknownHostException {
//InetAddress address = InetAddress.getByName("itheima");
InetAddress address = InetAddress.getByName("192.168.1.66");
//public String getHostName()：获取此IP地址的主机名
String name = address.getHostName();
//public String getHostAddress()：返回文本显示中的IP地址字符串
String ip = address.getHostAddress();
System.out.println("主机名：" + name);
System.out.println("IP地址：" + ip);
}
}

  • 域名：由于IP地址不宜记忆，引入网络域名来确认IP地址。

  • 端口：IP地址可以精确地确定一台主句，但是这台主机上可能运行着多个程序；可以借助主机端口精确地确定客户访问的是这台主机中的哪一个应用程序。【1~1024之内的端口号被系统占用，不可以用】

  • URL:网络上的资源

TCP/UDP协议

网络传输的过程中数据的传递有两种最常见的形式：

  • TCP传输控制协议：是一种面向连接的、可靠的、基于字节流传输层通信协议,由于这种面向连接的特性， TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等

    • 三次握手：

      三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠
第一次握手，客户端向服务器端发出连接请求，等待服务器确认
第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求
第三次握手，客户端再次向服务器端发送确认信息，确认连接

  • UDP用户数据报协议是一种无连接的传输协议，提供面向事务的简单不可靠信息传送服务。

    • 无需建立网络双方连接，直接发送数据包（包含目的地址信息），可能会因为网络问题导致数据传输失败等问题，但是传输速度很块，常用于局域网传输数据。

常见开发模型C/S|B/S

  • 客户端/服务器模式（C/S模式）：对于不同的服务端程序建立不同的客户端程序
    • 在网络编程中，C/S模式应用程序的开发，需要同时开发客户端应用程序和服务器端应用程序
  • 浏览器/服务器模式（B/S模式）：对于不同的服务器使用统一的”客户端“（即浏览器）即可
    • B/S模式应用程序的开发，由于客户端使用浏览器访问，服务器端应用程序本质上属于Web应用程序；浏览器和服务器通信协议采用HTTP协议

URL即应用

在java语言中，提供了一组URL处理类，封装了Socket编程技术的实现细节，用来方便开发人员进行网络连接、网络数据传输等常用的网络任务。

例子：保存网页中的内容：

public class Demo {
    public static void main(String[] args) throws IOException {
        //在百度上找到想复制的图片，右键复制图片链接
        String url_str="https://files.codelife.cc/itab/search/baidu.svg";
        //创建URL对象
        URL url=new URL(url_str);
        //获得网络输入流
//        InputStream is=url.openConnection().getInputStream();
        InputStream is=url.openStream();
        //创建文件输出流保存数据
        OutputStream os=new FileOutputStream("E:\\yyyc.svg");
        int len;
        while((len=is.read())!=-1){
            //写入文件
            os.write(len);
        }
        is.close();
        os.close();
        System.out.println("下载完成");
    }

TCP Socket ServerSocket

  • 客户端Socket应用程序锁做的工作主要有3步：

    1.与服务器端建立连接（通过IP和端口号确定主机上的程序）
Socket  client  =  new Socket(“localhost”,  80)
2.向服务器端发送数据，接收服务器端数据
向服务器端发送数据：os  =  client.getOutputStream()
接收服务器端数据：is  =  client.getInputStream()
3.关闭Socket连接
client.close()

  • 服务器端所作的主要工作有4步：

    1.监听特定端口
ServerSocket  server  =  new  ServerSocket(8888)
2.接收客户端连接
Socket  client  =  server.accept()
3.接收客户端请求，向客户端发送响应
接收客户端请求数据：is  =  client.getInputStream()
向客户端响应数据：os  =  client.getOutputStream()
4.关闭连接
关闭服务器端：server.close()

UDP DatagramSocket

  • DatagramSocket类：客户端/服务端网络Socket端口对象

    构造方法：
DatagramSocket（）;   // 创建一个空的Socket对象
DatagramSocket（int  port）;  // 创建指定监听端口的Socket对象
常用方法：
void  send（DatagramPacket  p）;  // 发送数据报文
void  receive（DatagramPacket  p）;  // 接收数据报文

  • DatagramPacket类：数据报文对象

     // 包含数据的数组创建对象，用来发送数据，同时指明数据目的地和目标端口号
DatagramPacket（byte[] buf, int len, InetAddress addr, int port）;

  • 客户端4步

    1.创建DatagramSocket对象
2.封装请求数据，
3.创建DatagramPacket对象
4.发送请求

  • 服务器端5步

    1.创建DatagramSocket对象，监听特定端口
2.创建DatagramPacket对象（空缓冲区）
3.接收客户端请求
4.封装服务器响应数据，创建DatagramPacket对象
5.发送服务器响应给指定客户端

TCP经典练习：

场景1：实现客户端，服务器端单次双向数据传输

​ 客户端发送，服务器端接收

​ 服务器端发送，客户端接收

案例需求
客户端：发送数据，接受服务器反馈
服务器：收到消息后给出反馈
案例分析
客户端创建对象，使用输出流输出数据
服务端创建对象，使用输入流接受数据
服务端使用输出流给出反馈数据
客户端使用输入流接受反馈数据

public class ServerDemo {
public static void main(String[] args) throws IOException {
//创建服务器端的Socket对象(ServerSocket)
ServerSocket ss = new ServerSocket(10000);
//监听客户端连接，返回一个Socket对象
Socket s = ss.accept();
//获取输入流，读数据，并把数据显示在控制台
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
int len = is.read(bys);
String data = new String(bys, 0, len);
System.out.println("服务器：" + data);
//给出反馈
OutputStream os = s.getOutputStream();
os.write("数据已经收到".getBytes());
//释放资源
// s.close();
ss.close();
}
}
public class ClientDemo {
public static void main(String[] args) throws IOException {
3.4TCP通信程序练习【应用】
案例需求
客户端：数据来自于键盘录入, 直到输入的数据是886，发送数据结束
服务端：接收到数据在控制台输出
案例分析
客户端创建对象，使用键盘录入循环接受数据，接受一行发送一行，直到键盘录入886为止
服务端创建对象，使用输入流按行循环接受数据，直到接受到null为止
代码实现
//创建客户端的Socket对象(Socket)
Socket s = new Socket("192.168.1.66", 10000);
//获取输出流，写数据
OutputStream os = s.getOutputStream();
os.write("hello,tcp,我来了".getBytes());
//接收服务器反馈
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
int len = is.read(bys);
String data = new String(bys, 0, len);
System.out.println("客户端：" + data);
//释放资源
// is.close();
// os.close();
s.close();
}
}

场景2：客户端多次输入服务器循环接收

1.

案例需求
客户端：数据来自于键盘录入, 直到输入的数据是886，发送数据结束
服务端：接收到数据在控制台输出
案例分析
客户端创建对象，使用键盘录入循环接受数据，接受一行发送一行，直到键盘录入886为止
服务端创建对象，使用输入流按行循环接受数据，直到接受到null为止


public class ClientDemo {
public static void main(String[] args) throws IOException {
//创建客户端Socket对象
Socket s = new Socket("192.168.1.66",10000);
//数据来自于键盘录入，直到输入的数据是886，发送数据结束
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//封装输出流对象
BufferedWriter bw = new BufferedWriter(new
OutputStreamWriter(s.getOutputStream()));
String line;
while ((line=br.readLine())!=null) {
if("886".equals(line)) {
break;
}
//获取输出流对象
bw.write(line);
bw.newLine();
3.5TCP通信程序练习【应用】
案例需求
客户端：数据来自于键盘录入，直到输入的数据是886,发送数据结束
服务端：接受到的数据写入文本文件中
案例分析
客户端创建对象，使用键盘录入循环接受数据，接受一行发送一行，直到键盘录入886为止
服务端创建对象，创建输出流对象指向文件，每接受一行数据后使用输出流输出到文件中，直到接受到
null为止
代码实现
bw.flush();
}
//释放资源
s.close();
}
}
public class ServerDemo {
public static void main(String[] args) throws IOException {
//创建服务器Socket对象
ServerSocket ss = new ServerSocket(10000);
//监听客户端的连接，返回一个对应的Socket对象
Socket s = ss.accept();
//获取输入流
BufferedReader br = new BufferedReader(new
InputStreamReader(s.getInputStream()));
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
//释放资源
ss.close();
}
}

2.

案例需求
客户端：数据来自于键盘录入，直到输入的数据是886,发送数据结束
服务端：接受到的数据写入文本文件中
案例分析
客户端创建对象，使用键盘录入循环接受数据，接受一行发送一行，直到键盘录入886为止
服务端创建对象，创建输出流对象指向文件，每接受一行数据后使用输出流输出到文件中，直到接受到
null为止


ublic class ClientDemo {
public static void main(String[] args) throws IOException {
//创建客户端Socket对象
Socket s = new Socket("192.168.1.66",10000);
//数据来自于键盘录入，直到输入的数据是886，发送数据结束
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//封装输出流对象
BufferedWriter bw = new BufferedWriter(new
OutputStreamWriter(s.getOutputStream()));
String line;
3.6TCP通信程序练习【应用】
案例需求
客户端：数据来自于文本文件
服务器：接收到的数据写入文本文件
案例分析
创建客户端，创建输入流对象指向文件，从文件循环读取数据，每读取一行就使用输出流给服务器输出
一行
创建服务端，创建输出流对象指向文件，从客户端接受数据，每接受一行就给文件中输出一行
代码实现
while ((line=br.readLine())!=null) {
if("886".equals(line)) {
break;
}
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
s.close();
}
}
public class ServerDemo {
public static void main(String[] args) throws IOException {
//创建服务器Socket对象
ServerSocket ss = new ServerSocket(10000);
//监听客户端连接，返回一个对应的Socket对象
Socket s = ss.accept();
//接收数据
BufferedReader br = new BufferedReader(new
InputStreamReader(s.getInputStream()));
//把数据写入文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\s.txt"));
String line;
while ((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
ss.close();
}
}

3.

案例需求
客户端：数据来自于文本文件
服务器：接收到的数据写入文本文件
案例分析
创建客户端，创建输入流对象指向文件，从文件循环读取数据，每读取一行就使用输出流给服务器输出
一行
创建服务端，创建输出流对象指向文件，从客户端接受数据，每接受一行就给文件中输出一行

public class ClientDemo {
3.7TCP通信程序练习【应用】
public static void main(String[] args) throws IOException {
//创建客户端Socket对象
Socket s = new Socket("192.168.1.66",10000);
//封装文本文件的数据
BufferedReader br = new BufferedReader(new
FileReader("myNet\\InetAddressDemo.java"));
//封装输出流写数据
BufferedWriter bw = new BufferedWriter(new
OutputStreamWriter(s.getOutputStream()));
String line;
while ((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
br.close();
s.close();
}
}
public class ServerDemo {
public static void main(String[] args) throws IOException {
//创建服务器Socket对象
ServerSocket ss = new ServerSocket(10000);
//监听客户端连接，返回一个对应的Socket对象
Socket s = ss.accept();
//接收数据
BufferedReader br = new BufferedReader(new
InputStreamReader(s.getInputStream()));
//把数据写入文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\Copy.java"));
String line;
while ((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
ss.close();
}
}

4.

案例需求
客户端：数据来自于文本文件，接收服务器反馈
服务器：接收到的数据写入文本文件，给出反馈
案例分析
创建客户端对象，创建输入流对象指向文件，每读入一行数据就给服务器输出一行数据，输出结束后使
用shutdownOutput()方法告知服务端传输结束
创建服务器对象，创建输出流对象指向文件，每接受一行数据就使用输出流输出到文件中，传输结束
后。使用输出流给客户端反馈信息
客户端接受服务端的回馈信息


public class ClientDemo {
public static void main(String[] args) throws IOException {
//创建客户端Socket对象
Socket s = new Socket("192.168.1.66",10000);
//封装文本文件的数据
BufferedReader br = new BufferedReader(new
FileReader("myNet\\InetAddressDemo.java"));
//封装输出流写数据
BufferedWriter bw = new BufferedWriter(new
OutputStreamWriter(s.getOutputStream()));
String line;
while ((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
//public void shutdownOutput()
s.shutdownOutput();
//接收反馈
BufferedReader brClient = new BufferedReader(new
InputStreamReader(s.getInputStream()));
String data = brClient.readLine(); //等待读取数据
System.out.println("服务器的反馈：" + data);
//释放资源
br.close();
s.close();

场景3：服务器多线程，客户端单线程

​ 主线程：负责等待，创建连接

​ 子线程：传输数据

案例需求
客户端：数据来自于文本文件，接收服务器反馈
服务器：接收到的数据写入文本文件，给出反馈，代码用线程进行封装，为每一个客户端开启一个线程
案例分析
创建客户端对象，创建输入流对象指向文件，每读入一行数据就给服务器输出一行数据，输出结束后使
用shutdownOutput()方法告知服务端传输结束
创建多线程类，在run()方法中读取客户端发送的数据，为了防止文件重名，使用计数器给文件名编号，
接受结束后使用输出流给客户端发送反馈信息。
创建服务端对象，每监听到一个客户端则开启一个新的线程接受数据。
客户端接受服务端的回馈信息

public class ClientDemo {
public static void main(String[] args) throws IOException {
//创建客户端Socket对象
Socket s = new Socket("192.168.1.66",10000);
//封装文本文件的数据
BufferedReader br = new BufferedReader(new
FileReader("myNet\\InetAddressDemo.java"));
//封装输出流写数据
BufferedWriter bw = new BufferedWriter(new
OutputStreamWriter(s.getOutputStream()));
String line;
while ((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
s.shutdownOutput();
//接收反馈
BufferedReader brClient = new BufferedReader(new
InputStreamReader(s.getInputStream()));
String data = brClient.readLine(); //等待读取数据
System.out.println("服务器的反馈：" + data);
//释放资源
br.close();
s.close();
}
}
public class ServerThread implements Runnable {
private Socket s;
public ServerThread(Socket s) {
this.s = s;
}
@Override
public void run() {
try {
//接收数据写到文本文件
BufferedReader br = new BufferedReader(new
InputStreamReader(s.getInputStream()));
//解决名称冲突问题
int count = 0;
File file = new File("myNet\\Copy["+count+"].java");
while (file.exists()) {
count++;
file = new File("myNet\\Copy["+count+"].java");
}
BufferedWriter bw = new BufferedWriter(new FileWriter(file));
String line;
while ((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
//给出反馈
BufferedWriter bwServer = new BufferedWriter(new
OutputStreamWriter(s.getOutputStream()));
bwServer.write("文件上传成功");
bwServer.newLine();
bwServer.flush();
//释放资源
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public class ServerDemo {
public static void main(String[] args) throws IOException {
//创建服务器Socket对象
ServerSocket ss = new ServerSocket(10000);
while (true) {
//监听客户端连接，返回一个对应的Socket对象
Socket s = ss.accept();
//为每一个客户端开启一个线程
new Thread(new ServerThread(s)).start();
}
}
}

场景4：服务器端多线程，客户端多线程

//客户端,(主线程:发送数据,子线程:接收数据)

class ClientThread extends Thread{
	private Socket socket;
	public ClientThread(Socket socket){
		this.socket =socket;
	}
	@Override
	public void run() {
//		接收数据
		InputStream is;
		try {
			is = this.socket.getInputStream();
			BufferedReader reader=new BufferedReader
					(new InputStreamReader(is));
			String result=reader.readLine();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	
}
public class Client {
	
	public static void main(String[] args) throws Exception {
//		Scanner对象实现键盘输入
		Scanner scanner = new Scanner(System.in);
		Socket socket = new Socket("127.0.0.1", 8888);

		
//		以下接收数据使用子线程实现
//		InputStream is = socket.getInputStream();
//		BufferedReader reader=new BufferedReader
//				(new InputStreamReader(is));
//		String result=reader.readLine();
		
		new ClientThread(socket).start();
	
//	     发送数据
		OutputStream os = socket.getOutputStream();
		
//		带缓冲的字符流，使用低级的字节流来构建
		BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os));
		System.out.println("请输入用户名：");
		while (true) {
			String input = scanner.nextLine();
			writer.write(input + "\n");
			writer.flush();
			if (input.startsWith("exit")) {
				break;
			}

		}
		
		

		writer.close();
		socket.close();
	}

}


//子线程负责数据传输，主线程负责接受客户端连接
class ServerTread extends Thread {
	private Socket socket;

	public ServerTread(Socket socket) {
		this.socket = socket;
	}

	@Override
	public void run() {

		InputStream is;
		OutputStream os;
		try {
			System.out.println(this.getName());
			is = socket.getInputStream();
			byte[] result = new byte[1024];
			is.read(result);
			String s1 = new String(result, "UTF-8");
			System.out.println(s1);

			os = socket.getOutputStream();
			os.write(new String("我是服务器").getBytes());
			os.flush();
			socket.close();

		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}

public class Server {
	public static void main(String[] args) throws Exception {
		ServerSocket server = new ServerSocket(8888);
		int i = 0;
		while (true) {
			System.out.println("等待连接");
			Socket socket = server.accept();
			System.out.println("连接成功");
			i++;
			if (i == 5) {
				break;
			}
			new ServerTread(socket).start();

		}
		server.close();
	}

}

UDP经典练习

场景1：单项的发送，接收

//发送端
public class Sender {
	public static void main(String[] args) throws Exception {
//		1、创建DatagramSocket对象，不需要指定端口
		DatagramSocket socket=new DatagramSocket(9000);
//		2、准备字节数组
		byte[] input="hello,Server".getBytes();
//		3、创建DatagramPacket对象，需要指定接收方的ip，端口号
		DatagramPacket packet=new DatagramPacket
				(input, 
				input.length,
				InetAddress.getByName("127.0.0.1"),
				8000);
//		4、发送数据
		socket.send(packet);
//		5、关闭连接
		socket.close();
	}

}
//接收方
public class Recevier {
	public static void main(String[] args) throws Exception {
//		1、创建DatagramSocket对象，需要指定端口号
		DatagramSocket socket = new DatagramSocket(8000);
		byte[] data = new byte[1024];
//		2、创建DatagramPacket
		DatagramPacket packet = new DatagramPacket
				(data, data.length);
		System.out.println("等待接收");
//		3、阻塞式接收
		socket.receive(packet);//阻塞式接收
		System.out.println("接收完成");
//		4、分析数据
		byte[] result=packet.getData();
		System.out.println(new String(result));
//		5、关闭Socket
		socket.close();

	}

}

场景2：双向的发送，接收

 * 实现双向的数据传输
 * 学生端先发送，后接收
 * 教师端先接收，后发送

public class Student {
	public static void main(String[] args) throws Exception {
//		1、创建DatagramSocket对象，不需要指定端口
		DatagramSocket socket=new DatagramSocket(9000);
//		2、准备字节数组
		byte[] input="我是学生端".getBytes();
//		3、创建DatagramPacket对象，需要指定接收方的ip，端口号
		DatagramPacket packet=new DatagramPacket
				(input, 
				input.length,
				InetAddress.getByName("127.0.0.1"),
				8000);
//		4、发送数据
		socket.send(packet);
		
//		接收数据
		byte[] result=new byte[1024];
		DatagramPacket packet2=new DatagramPacket
				(result, result.length);
		
		socket.receive(packet2);
		byte[] data=packet2.getData();
		System.out.println(new String(data));	
		
//		5、关闭连接
		socket.close();
	}
}

public class Teacher {
	public static void main(String[] args) throws Exception {
//		1、创建DatagramSocket对象，需要指定端口号
		DatagramSocket socket = new DatagramSocket(8000);
		byte[] data = new byte[1024];
//		2、创建DatagramPacket
		DatagramPacket packet1 = new DatagramPacket
				(data, data.length);
		System.out.println("等待接收");
//		3、阻塞式接收
		socket.receive(packet1);//阻塞式接收
		System.out.println("接收完成");
//		4、分析数据
		byte[] result=packet1.getData();
		System.out.println(new String(result));
		
//		发送数据
		
		byte[] input="我是教师端".getBytes();
		DatagramPacket packet2 = new DatagramPacket
				(input,
					input.length,
					InetAddress.getByName("127.0.0.1"),
					9000
					);
		socket.send(packet2);
		
//		5、关闭Socket
		socket.close();

	}
}

场景3：键盘输入的字符串进行发送，发送多次，接收多次，while

案例需求
UDP发送数据：数据来自于键盘录入，直到输入的数据是886，发送数据结束
UDP接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收

public class SendDemo {
public static void main(String[] args) throws IOException {
//创建发送端的Socket对象(DatagramSocket)
DatagramSocket ds = new DatagramSocket();
//自己封装键盘录入数据
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line;
while ((line = br.readLine()) != null) {
//输入的数据是886，发送数据结束
if ("886".equals(line)) {
break;
}
//创建数据，并把数据打包
byte[] bys = line.getBytes();
DatagramPacket dp = new DatagramPacket(bys, bys.length,
InetAddress.getByName("192.168.1.66"), 12345);
//调用DatagramSocket对象的方法发送数据
ds.send(dp);
}
//关闭发送端
ds.close();
}
}
/*
UDP接收数据：
因为接收端不知道发送端什么时候停止发送，故采用死循环接收
*/
public class ReceiveDemo {
public static void main(String[] args) throws IOException {
//创建接收端的Socket对象(DatagramSocket)
DatagramSocket ds = new DatagramSocket(12345);
while (true) {
//创建一个数据包，用于接收数据
byte[] bys = new byte[1024];
DatagramPacket dp = new DatagramPacket(bys, bys.length);
//调用DatagramSocket对象的方法接收数据
ds.receive(dp);
//解析数据包，并把数据在控制台显示
System.out.println("数据是：" + new String(dp.getData(), 0,
dp.getLength()));
}
//关闭接收端
// ds.close();
}
}

场景4：子线程1负责发送，子线程2负责接收，老师端、学生端都启用了两个子线程

public class ChatRecevier implements Runnable {
	
	DatagramSocket socket;
	String from;

	public ChatRecevier(int port,String from) throws Exception {
		socket =new DatagramSocket(port);
		this.from=from;
	}
	@Override
	public void run() {
	
		while (true) {
			byte[] data=new byte[1024];
			DatagramPacket packet=new DatagramPacket
					(data, data.length);
			try {
				socket.receive(packet);
				byte[] result=packet.getData();
				String print_str=new String(result);
				System.out.println(from+print_str);
				if(print_str.startsWith("bye")) {
					break;
				}
				
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			
		}
		
		
		
	}

}


public class ChatSender implements Runnable{
	DatagramSocket socket;
	String to_ip;
	int to_port;
	BufferedReader br;
	public ChatSender(String ip,int port) throws SocketException {
//		1、创建DatagramSocket对象，不需要指定端口
	 socket=new DatagramSocket();
	 this.to_ip=ip;
	 this.to_port=port;
	 br=new BufferedReader
				(new InputStreamReader(System.in));
	}
	@Override
	public void run() {
		
		while (true) {
		
			String result;
			try {
				result = br.readLine();
				byte[] input=result.getBytes();
				
//				3、创建DatagramPacket对象，需要指定接收方的ip，端口号
				DatagramPacket packet=new DatagramPacket
						(input, 
						input.length,
						InetAddress.getByName(this.to_ip),
						this.to_port);
//				4、发送数据
				socket.send(packet);
				if (result.startsWith("bye")) {
					break;
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}

		

		
		
//		5、关闭连接
		socket.close();
		
		
	}

}


public class Student {
	public static void main(String[] args) throws Exception {
		new Thread(new ChatRecevier(8000, "教师说：")).start();
		new Thread(new ChatSender("127.0.0.1", 9000)).start();
	}

}

public class Teacher {
public static void main(String[] args) throws Exception {
	new Thread(new ChatRecevier(9000, "学生说：")).start();
	new Thread(new ChatSender("127.0.01", 8000)).start();
}
}

场景5：发送其他数据

public class Recevier {
public static void main(String[] args) throws Exception {
	DatagramSocket socket=new DatagramSocket(8000);
	byte[] cache=new byte[1024];
	DatagramPacket packet=new DatagramPacket(cache, cache.length);
	socket.receive(packet);
	
	ByteArrayInputStream bis=
			new ByteArrayInputStream(packet.getData());
	DataInputStream dis=new DataInputStream(bis);
	
	System.out.println(dis.readDouble()); 
	System.out.println(dis.readUTF());
	System.out.println(dis.readInt());
}

}

//发送多种类型的数据
public class Sender {
	public static void main(String[] args) throws IOException {
		DatagramSocket socket=new DatagramSocket();
		
		ByteArrayOutputStream bos=new ByteArrayOutputStream();
		DataOutputStream dos=new DataOutputStream
				(new BufferedOutputStream(bos));
		dos.writeDouble(2.2334);
		dos.writeUTF("hello");
		dos.writeInt(20);
		dos.flush();
		
		byte[] data=bos.toByteArray();
		
		DatagramPacket packet=new DatagramPacket
				(data, data.length,
						InetAddress.getByName("127.0.0.1")
						,8000);
		socket.send(packet);
		
	
	}

}
Sheep6erder
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
少儿编程scratch -- 基础篇（教学）
codercjw的博客
05-15 3271
基本上只要认真上完老师的课，并且做到所有的程序都会敲的话，就可以去参加考级了。青少年编程考级(scratch图形化编程一般是1到4级）让小朋友熟悉人物，背景，说话，思考模块怎么用。认识一下软件的各个区域。
网络基础设施测试的趋势与未来方向 （一）· AEM
kaianding的博客
06-10 130
AEM 关于认证、资格和验证 AEM在这些“传统”类别中提供解决方案，我将对此进行概述。但是，我们也认识到，现代网络基础设施需要新的测试和故障排除方法，这要求需要更广泛的测试功能。为了满足该测试需求，用户不幸地需要购买跨越传统类别的两种甚至三种不同类型的测试设备，以便满足所需的全部测试范围。大多数组织没有足够的预算来支持这一点，最终导致他们无法满足某些所需的测试需求。为此，AEM采用了一种创新方法来创建新类别Qualification +，从而在单个混合测试解决方案中弥合了验证/鉴定与认证测试之间的鸿沟。
Java网络编程
zzh1324的博客
11-09 100
udp发送数据 import java.io.IOException; import java.net.*; public class senddemo { public static void main(String[] args) throws IOException { //创建发送断的socket对象（DatagramSocket） //DatagramSocket（）构造数据报套接字并将其绑定到本地主机上的任何可用端口 DatagramSo
【基础提升】网络编程知多少？！
mukvintt的博客
12-18 208
今天，咱们来说下网络编程相关的知识！ 网络编程网络编程，其实还请原谅，我自己也只是个懵懂的娃，还是一知半解的那种，这让我很不爽。 今天就是要把这块空白稍微补一补，咋地不能说精通，但是必须要了解一丢丢不是！ 目录 一、面向网络编程总结 1.1 网络协议 1.2 IP地址和端口号 1.3 InetAddress 二、UDP 协议 2.1 DatagramPacket  2.2 Da...
JAVA学习笔记18 网络编程之TCP通信（2）
qq_43336475的博客
01-09 278
TCP模型下基础的Client-Server发送消息与接收消息 Sever： package Net; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; public class ServerDemo { public static void main(String[] args) throws IOException {...
网络安全-自学笔记
热门推荐
关注网络安全、云原生安全
12-01 16万+
目录 WEB（应用）安全 前端安全 xss攻击 后端安全 文件上传漏洞 WebShell 解析安全 数据安全 sql注入 通信安全 WEB（应用）安全 前端安全 xss攻击 后端安全 文件上传漏洞 WebShell 解析安全 数据安全 sql注入 网络安全-sqlmap学习笔记 通信安全 网络-http协议学习笔记（消息结构、请求方法、状态码等） ...
点点点工程师自我提升&运维方向----shell编程基础知识盘点
qxj2422640226的博客
03-19 7084
shell编程 1. 工作范围     1. 海量运维&运营规划         1. 规划 架构规划 IDC规划 ISP规划 服务器规划 预算规划         2. 管理 配置管理 事件管理 问题管理 成本管理 容量管理 资源管理 需求管理     
软件测试基础知识 - 测试开发需要哪些知识，需要具备什么能力
了解➔熟悉➔掌握➔精通
02-03 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net Definition Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subcla...
Java 网络编程
ZaynFox的博客
05-30 6万+
网络编程 一、网络编程基础概念 首先理清一个概念：网络编程不等于网站编程，网络编程即使用套接字来达到进程间通信，现在一般称为TCP/IP编程。 计算机网络： 把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大，功能强的网络系统，从而使众多的计算机可以方便的互相传递信息，共享硬件，软件，数据信息等资源。 计算机网络的主要功能： 资源共享 信息传输与集中处理 均衡负荷与分布处理 ...
（头歌）Java程序设计--------Java编程基础
zfl0529的博客
06-04 3820
第1关：关键字。
网络技术-网络基础-泵车无线遥控器的设计与实现.pdf
04-19
接下来详细讨论了各个功能模块的设计，最后可能还包括系统测试、性能评估和未来改进方向的探讨。 通过这样的设计，新型泵车无线遥控器有望为建筑行业带来显著的经济效益和社会效益，推动工程机器自动化水平的提升，...
资源专区-课程设计-编程作业-计算机网络基础资源-计算机网络、现代通信组网相关的教程&案例&相关项目
06-18
总的来说，这个资源专区提供了全面的计算机网络和现代通信组网的学习资料，无论是对网络基础知识的掌握，还是对网络编程和实际应用的理解，都能提供有力的支持。对于想要深入学习计算机网络的学员来说，这是一个宝贵...
少儿青少年编程python入学测试文档
11-22
这份"少儿青少年编程python入学测试文档"旨在评估孩子们对编程基础知识的掌握程度，以及他们对Python的兴趣和期望，以便制定合适的教学计划。 1. **编程基础知识**： 测试中提到的乐高积木课程和硬件相关课程是...
网络编程课程设计-Python实现网络聊天室（源码 + 说明文档 + 论文）
05-20
完成项目后，撰写论文是对所做工作的总结和理论阐述，包括项目目标、技术选型、设计思路、实现过程、功能测试以及可能的改进方向等内容，有助于提升对网络编程的理解和研究能力。 综上，"Python实现网络聊天室"项目...
proyecto-dinamica:网络编程专业
03-13
"原动力"可能是指推动网络编程发展的基础原理和技术进步。 【描述】"原动力"一词暗示了网络编程的基础和核心概念。这可能包括TCP/IP协议栈、HTTP协议、Socket编程等基础知识。网络编程的专业学习通常会从理解网络...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1212
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 502
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 803
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 278
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
Java基础编程与测试实验报告-朱明彦
"朱明彦同学的实验报告，属于计算机学院大二软件构造课程的Lab1，涵盖了Java基础编程与测试。报告详细介绍了实验过程，包括MagicSquares、TurtleGraphics、SocialNetwork以及选作的TweetTweet项目。实验旨在提升Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值