core java--day22（网络编程实例6，udp）

最新推荐文章于 2024-04-16 16:33:40 发布

小问题--的文

最新推荐文章于 2024-04-16 16:33:40 发布

阅读量144

点赞数 1

分类专栏： java 文章标签：网络编程实例6 udp

本文链接：https://blog.csdn.net/qq_41533897/article/details/100837402

版权

java 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

复习：

RandomAccessFile:
   文件
   seek();
   getFilePorinter();
   length();
   byte[] but = new byte[end-start];

序列化 :
   把对象写到文件
   ObjectOutputStream
   writeObject();
反序列化 :
   把文件对象读取到代码
   ObjectInputStream
   readObject();

Data + Object InputStream

网络编程 :
   数据交互
   局域网
   ping 127.0.0.1

ip地址 : 唯一表示一台电脑
port端口 : 电脑上的某一个程序

ServerSocket : 服务器端
   被访问
客户端      :
   提供图形界面-->操作服务器端

创建服务器 :
   ServerSocket server
       = new ServerSocket(8099);
监听是否有访问:
   Socket socket = server.accept();
用户的ip地址
   socket.getInetAddress();
和用户连接的输入
   服务器端有数据输入(客户端发过来的)
   InputStream in = socket.getInputStream();
和用户连接的输出
   服务器端有数据输出(输出到客户端)
   OutputStream out = socket.getOutputStream();

服务器和客户端聊天

服务器 : 聊天
    读客户端发送过来的数据
   read();//阻塞
    还要写数据到客户端

客户端 : 聊天
读服务器发送过来的数据
还要写数据到服务器端

需要两个线程:
   读数据的线程
       死循环读
   写数据的线程
       while(){
           读取控制台的数据
           然后写出去
       }

Socket=Ip address+ TCP/UDP + port。
区分不同应用程序进程间的网络通信和连接,
主要有3个参数:通信的目的IP地址、使用的传输层协议(TCP或UDP)和使用的端口号。
Socket原意是 "插座"。
通过将这3个参数结合起来，与一个"插座"Socket绑定，
应用层就可以和传输层通过套接字接口，
区分来自不同应用程序进程或网络连接的通信，实现数据传输的并发服务。
套接字之间的连接过程可以分为三个步骤:服务器监听、客户端请求、连接确认。

服务器监听是指服务端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态。

客户端请求是由客户端的套接字提出连接请求，要连接的目标是服务器端套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器套接字的地址和端口号，然后再向服务器端套接字提出连接请求。

连接确认是当服务器端套接字监听到或者说接收到客户端套接字的连接请求时，它就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的信息发送给客户端，一旦客户端确认了此连接，连接即可建立。而服务器端继续处于监听状态，继续接收其他客户端的连接请求。

3.2 : 客户端程序编写：
        1,调用Socket()创建一个流套接字，并连接到服务器端；
        2,调用Socket类的getOutputStream()和getInputStream获取输出流和输入流，开始网络数据的发送和接收；
        3,最后关闭通信套接字。
   3.3 : 常用方法使用:
        getInetAddress(); 返回套接字所连接的地址。
        getInputStream(); 返回与客户端连接的输入流
        getOutputStream();返回与客户端连接的输出流
        getLocalAddress();获取套接字所绑定的本地地址。

基于UDP的Socket编程步骤：
传输层：
UDP：是无连接的，不可靠的传输协议；采用UDP协议进行通信时，不需要建立连接，可以直接向一个IP地址发送数据，至于是不是能够收到不能保证，发送过程中数据有可能丢失、IP地址可能不存在、再者IP地址代表的主机没有运行等原因都可能导致不能接收到数据。

1）接收端程序编写：
    ①调用DatagramSocket(int port)创建一个数据报套接字，并绑定到指定端口上；
    ②调用DatagramPacket(byte[] buf, int length)，建立一个字节数组以接收UDP包；
    ③调用DatagramSocket类的receive()，接收UDP包；
    ④最后关闭数据报套接字。
2）发送端程序编写：
    ①调用DatagramSocket()创建一个数据报套接字；
    ②调用DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)，建立要发送的UDP包；
    ③调用DatagramSocket类的send()，发送UDP包；
    ④最后关闭数据报套接字。

package com.briup.ch22.t1;

import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

//服务器端
public class MyServer1 {
	public static void main(String[] args) throws Exception {
		System.out.println("服务器端启动");
		ServerSocket server = new ServerSocket(8099);
		while(true) {
			//接受到用户的连接
			Socket socket = server.accept();
			//客户端连接 服务器就给客户端写一句话
			while(true) {
				//获得和客户端连接的输出流
				OutputStream out = socket.getOutputStream();
				out.write("欢迎来到jd1907".getBytes());
				out.write(13);
				out.write(10);
				Thread.sleep(1000);
			}
		}
	}
}

package com.briup.ch22.t1;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

//客户端,需要接受服务器端发送的数据
public class MyClient1 {
	public static void main(String[] args) throws Exception {
		//1,创建客户端
		//表示和服务器端连接成功
		Socket socket = 
				new Socket("127.0.0.1",8099);
		//2,读取服务器发送过来的数据
		InputStream in = socket.getInputStream();
		InputStreamReader isr = 
				new InputStreamReader(in,"UTF-8");
		BufferedReader br = 
				new BufferedReader(isr);
		
		String da = "";
		while(   (da = br.readLine())!=null   ) {
			System.out.println("客户端读取到 :"+da);
		}
		
		br.close();
		isr.close();
		in.close();
		socket.close();
	}
}

package com.briup.ch22.t2;

import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.UUID;

/**
 * 二号服务器，使用线程来处理多个客户端
 * */
public class MyServer2 {
	
	public static void main(String[] args) throws Exception {
		System.out.println("服务器启动2");
		ServerSocket server = 
				new ServerSocket(8099);
		//死循环监听客户端连接
		while(true) {
			//和客户端连接的对象
			Socket socket = server.accept();
			//使用线程处理这个 [客户端]
			My2 t = new My2(socket);
			t.start();
		}
	}
}
//这个线程用来处理客户端
class My2 extends Thread{
	Socket socket;
	public My2(Socket socket) {
		this.socket = socket;
	}
	@Override
	public void run() {
		try {
			OutputStream out = socket.getOutputStream();
			while(true) {
				String msg = UUID.randomUUID().toString();
				out.write(msg.getBytes());
				out.write(13);
				out.write(10);
				out.flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

package com.briup.ch22.t2;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

//客户端,需要接受服务器端发送的数据
public class MyClient2 {
	public static void main(String[] args) throws Exception {
		//1,创建客户端
		//表示和服务器端连接成功
		Socket socket = 
				new Socket("127.0.0.1",8099);
		//2,读取服务器发送过来的数据
		InputStream in = socket.getInputStream();
		InputStreamReader isr = 
				new InputStreamReader(in,"UTF-8");
		BufferedReader br = 
				new BufferedReader(isr);
		
		String da = "";
		while(   (da = br.readLine())!=null   ) {
			System.out.println("客户端2读取到 :"+da);
		}
		
		br.close();
		isr.close();
		in.close();
		socket.close();
	}
}

package com.briup.ch22.t3;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

//读数据的线程
public class Read extends Thread{
	//和客户端  和 服务器端连接的对象
	Socket socket;
	public Read(Socket socket,String name) {
		this.socket = socket;
		setName(name);
	}
	@Override
	public void run() {
		try {
			InputStream in = socket.getInputStream();
			InputStreamReader isr = new InputStreamReader(in, "UTF-8");
			BufferedReader br = new BufferedReader(isr);
			
			String msg = "";
			while(true) {
				String da = br.readLine();
				System.out.println(getName()+":"+da);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

package com.briup.ch22.t3;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;

/**
 * 写数据到 服务器 或者写数据到客户端
 * 172.16.6.123
 * */
public class Writer extends Thread{
	Socket socket;
	public Writer(Socket socket,String name) {
		this.socket = socket;
		setName(name);
	}
	@Override
	public void run() {
		try {
			OutputStream out = socket.getOutputStream();
			InputStream in = System.in;
			InputStreamReader isr = new InputStreamReader(in, "UTF-8");
			BufferedReader br = new BufferedReader(isr);
			while(true) {
				//从当前控制台，键盘输入的数据
				String da = br.readLine();
				//把数据 写到 客户端
				out.write(da.getBytes());
				out.write(13);
				out.write(10);
				out.flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

package com.briup.ch22.t3;

import java.net.ServerSocket;
import java.net.Socket;

/**
 * 客户端和服务器端聊天的测试<br>
 * 服务器 : 172.16.6.123
 * */
public class MyServer3 {
	public static void main(String[] args) throws Exception {
		System.out.println("172.16.6.123:8099 - 服务器启动");
		ServerSocket server = new ServerSocket(8099);
		while(true) {
			//监听客户端的连接
			Socket socket = server.accept();
			System.out.println("有客户端连接 :"
						+socket.getInetAddress());
			//开启两个线程
			Read r = new Read(socket, "小明");
			r.start();
			Writer w = new Writer(socket, "小明");
			w.start();
		}
	}
}

package com.briup.ch22.t3;

import java.net.Socket;

/**
 * 聊天客户端<br>
 * 
 * */
public class MyClinet3 {
	public static void main(String[] args) throws Exception {
		//cmd ipconfig
		Socket socket =new Socket("127.0.0.1",8099);
		System.out.println("客户端连接服务器成功:");
		System.out.println("开始聊天");
		//开启两个线程
		Read r = new Read(socket, "小红");
		r.start();
		Writer w = new Writer(socket, "小红");
		w.start();

	}
}

package com.briup.ch22.t4;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

//服务器端 用来存储数据
public class MyServer4 {
	public static void main(String[] args) throws Exception {
		System.out.println("172.16.6.123:8099服务器启动");
		ServerSocket server = new ServerSocket(8099);
		//和客户连接的 socket 对象
		Socket socket = server.accept();
		//把客户端发送过来的数据 存储
		InputStream in = socket.getInputStream();
		
		//把用户发送过来的数据 保存到本地
		File file = File.createTempFile
				("youimage", ".jpg",new File("D://"));
		FileOutputStream fos = 
				new FileOutputStream(file);
		
		//保存学生 / 发图片
		int da = 0;
		while((da = in.read())!=-1) {
			fos.write(da);
			fos.flush();
		}
		fos.close();
		in.close();
		socket.close();
	}
}

package com.briup.ch22.t4;

import java.io.FileInputStream;
import java.io.OutputStream;
import java.net.Socket;

//把本地的图片传到服务器  172.16.6.123
public class MyClient4 {
	public static void main(String[] args) throws Exception {
		Socket socket = new Socket("127.0.0.1",8099);
		//和服务器端连接的输出流
		OutputStream out = socket.getOutputStream();
		
		//读取客户端本地文件的字节
		FileInputStream fis = 
				new FileInputStream("6.png");
		int da  = 0;
		while(  (da = fis.read())!=-1  ) {
			out.write(da);
			out.flush();
		}
		//写回一个-1
		out.write(128);
		out.flush();
		
		fis.close();
		out.close();
		
		
	}
}

package com.briup.ch22.t5;

import java.io.InputStream;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class MyServer5 {
	public static void main(String[] args) throws Exception {
		
		System.out.println("172.16.6.123:8099服务器启动");
		ServerSocket server = new ServerSocket(8099);
		//和客户连接的 socket 对象
		Socket socket = server.accept();
		//把客户端发送过来的数据 存储
		InputStream in = socket.getInputStream();
		
		ObjectInputStream ois =
				new ObjectInputStream(in);
		
		Object object = ois.readObject();
		
		System.out.println("服务器端接收");
		System.out.println(object);
		ois.close();
		in.close();
		socket.close();
		server.close();
	}
}

package com.briup.ch22.t5;

import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;

import com.briup.ch21.Student;

public class MyClient5 {
	public static void main(String[] args) throws Exception {
		
		Socket socket = new Socket("127.0.0.1",8099);
		//和服务器端连接的输出流
		OutputStream out = socket.getOutputStream();
		
		ObjectOutputStream oos = 
				new ObjectOutputStream(out);
		//客户端写了一个对象到 服务器端
		oos.writeObject(new Student(10, "tom123"));
		
		oos.flush();
		oos.close();
		out.close();
		socket.close();
		
	}
}

package com.briup.ch22.t6;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashSet;
import java.util.Set;

/**
 * 多人聊天室<Br>
 * 服务器端
 */
public class MyServer6 {
//使用变量接收所有客户端
	public static Set<Socket> sockets = new HashSet<Socket>();

	public static void main(String[] args) throws Exception {
		System.out.println("服务器启动");
		ServerSocket server = new ServerSocket(8099);
		while (true) {
			// 某一个客户端
			Socket socket = server.accept();
			// 添加客户端 到容器中
			sockets.add(socket);

			My6 t = new My6(socket);
			t.start();
		}
	}

	public static void show(String msg) {
		try {
			for (Socket cli : sockets) {
				// 获得每一个和服务器连接的客户端
				OutputStream cliOut = cli.getOutputStream();
				cliOut.write(msg.getBytes());
				cliOut.write(13);
				cliOut.write(10);
				cliOut.flush();
			}
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

//处理 用户的请求
class My6 extends Thread {
	Socket socket;

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

	@Override
	public void run() {
		try {
			OutputStream out = socket.getOutputStream();
			InputStream in = socket.getInputStream();
			InputStreamReader isr = new InputStreamReader(in, "UTF-8");
			BufferedReader br = new BufferedReader(isr);

			out.write("欢迎来到聊天室".getBytes());
			out.write(13);
			out.write(10);
			out.flush();
			out.write("请输入用户名:\r\n".getBytes());
			out.flush();
			// 读取用户输入的用户名
			String name = br.readLine();
			setName(name);
			out.write("开始和大家聊天吧\r\n".getBytes());
			out.flush();
			while (true) {
				// 读取用户本次输入的数据
				String msg = getName()+":"+br.readLine();
				// 把msg 转发给所有的用户
				MyServer6.show(msg);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

package com.briup.ch22.t6;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;

import com.briup.ch22.t3.Read;

//客户端
public class MyClinet {
	public static void main(String[] args) throws Exception {
		Socket socket = new Socket("127.0.0.1",8099);
		//读取服务器的信息
		InputStream in = socket.getInputStream();
		InputStreamReader isr = new InputStreamReader(in, "UTF-8");
		BufferedReader br = new BufferedReader(isr);
		System.out.println(br.readLine());
		System.out.println(br.readLine());
		
		//从控制台读取字符串
		InputStream insys = System.in;
		InputStreamReader isrsys = new InputStreamReader(insys, "UTF-8");
		BufferedReader brsys = new BufferedReader(isrsys);
		//读取控制台的用户名
		String name = brsys.readLine();
		OutputStream out = socket.getOutputStream();
		out.write(name.getBytes());
		out.write(13);
		out.write(10);
		out.flush();
		System.out.println(br.readLine());
		//一直读服务器 广播出来的数据
		Read r = new Read(socket, name);
		r.start();
		
		while(true) {
			//从控制台读取数据，
			//写到服务器
			String msg = brsys.readLine();
			out.write(msg.getBytes());
			out.write(13);
			out.write(10);
			out.flush();
		}
		
	}
}

package com.briup.ch22.t7;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

//udp 服务器端
public class MyUdpServer6 {
	public static void main(String[] args) throws Exception {
		System.out.println("服务器开启");
		DatagramSocket ds 
			= new DatagramSocket(8099);
		while(true) {
			//接收数据包
			byte[] buf = new byte[30];
			//使用这个buf接收数据，数据都放到字节数组中
			DatagramPacket p =
				new DatagramPacket(buf, buf.length);
			ds.receive(p);
			System.out.println("服务器端接收到");
			System.out.println(new String(buf));
		}
	}
}

package com.briup.ch22.t7;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

//udp 编程  客户端
public class MyUdpClient7 {
	public static void main(String[] args) throws Exception {
		//创建客户端，构造器中不写
		DatagramSocket ds = new DatagramSocket();
		//客户端连接服务器端
		InetAddress address = 
			InetAddress.getByName("127.0.0.1");
		//成功建立连接
		ds.connect(address, 8099);
		//发送数据包
		byte[] buf = "hello-- world".getBytes();
		DatagramPacket p = 
			new DatagramPacket(buf, buf.length);
		ds.send(p);
		System.out.println("客户端 数据发送成功");
	}
}

小问题--的文

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
core java--day22（网络编程实例6，udp）

复习：RandomAccessFile: 文件 seek(); getFilePorinter(); length(); byte[] but = new byte[end-start];序列化 : 把对象写到文件 ObjectOutputStream writeObject();反序列化 : 把文件对象读取...
复制链接

扫一扫