网络编程中的TCP传输和UPD传输

最新推荐文章于 2024-08-16 19:03:26 发布

nancy199006

最新推荐文章于 2024-08-16 19:03:26 发布

阅读量1k

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/nancy199006/article/details/43639863

本文详细介绍了Java网络编程的基础知识，包括IP地址获取、UDP与TCP传输协议的特点、UDP图片传输实例，以及如何实现图片上传功能。通过具体代码示例，展示了如何在客户端读取图片文件并发送至服务器，服务器接收并保存图片的过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package javalianxi;
/**
 * 
 * @author zhaocx1
 * 
 */
import java.net.InetAddress;//导入net包中的类包
public class IPDemo {
	public static void main(String[] args) throws Exception
	{
		//InetAddress i=InetAddress.getLocalHost();//获取本机的名称
		//System.out.println(i.toString());
		//System.out.println("address="+i.getHostAddress());//获取本机的IP地址
		//System.out.println("name="+i.getHostName());//获取本机用户的名称
		
		InetAddress ia=InetAddress.getByName("www.hjytdz.com");
		System.out.println("address="+ia.getHostAddress());//获取某一指定用户的IP地址
		System.out.println("name="+ia.getHostName());//获取某一指定用户的名称
	}

package javalianxi;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * UDP特点：
 * 1.将数据及源和目的封装成数据包，不需要建立连接。
 * 2.每个数据包的大小限制在64k内
 * 3.因无连接，是不可靠协议
 * 4.不需要建立连接，速度快
 * 如：qq 飞信都是UDP
 * 
 * TCP特点：
 * 1.建立连接，形成传输数据的通道
 * 2.在连接中进行大数据传输
 * 3.通过三次握手完成连接，是可靠协议
 * 4.必须建立连接，效率会稍低
 * 如：打电话。
 * 
 */
public class UDPandTCP {
	public static void main(String[] args) {
		System.out.println("hello wrold");
	}

}

package javalianxi;
import java.net.DatagramPacket;//导入net包中的类包
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 通过UDP传输方式，将一段文字传输发送出去。
 * 思路：
 * 1.建立udpsocket服务。
 * 2.提供数据，并将数据封装到数据包中。
 * 3.通过socket服务的发送功能，将数据包发出去。
 * 4.关闭资源。
 */
public class UDPDemo {
	public static void main(String[] args)throws Exception
	{
		//1.创建udp服务，通过DatagramSocket对象。
		DatagramSocket ds=new DatagramSocket();
		
		//2.确定数据，并封装成数据包。
		byte[] buf="udp lai le".getBytes();
		DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.103"),1000);
		
		//3.通过socket服务，将已有的数据包发送出去，通过send方法。
		ds.send(dp);
		
		//4.关闭资源。
		ds.close();
	}

}

package javalianxi;
import java.io.BufferedReader;//导入IO流包中类包
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;//导入net包中的类包
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
 * 
 * @author zhaocx1
 * 通过键盘录入对数据进行传输
 */

/**
 * 
 * @author zhaocx1
 * 
 */
class UDPSend2 {//定义一个类，用于定义发送端的方法
	public static void main(String[] args) throws IOException {
		//建立UPD服务，建立发送端
		DatagramSocket ds = new DatagramSocket();
		//通过键盘录入将信息进行传输
		BufferedReader bufr = new BufferedReader(new InputStreamReader(
				System.in));
		String line = null;
		//对数据进行读取
		while ((line = bufr.readLine()) != null) {
			//定义一个标记，当键盘录入该标记时，程序运行停止
			if ("886".equals(line))//定义一个标记，当键盘录入该标记时，程序运行停止
				break;
			//定义一个数组，用于存储到的数据
			byte[] buf = line.getBytes();
			//定义一个数据包，将读到的数据封装到数据包中，并指定发送的IP地址及端口
			DatagramPacket dp = new DatagramPacket(buf, buf.length,
					InetAddress.getByName("192.163.1.103"), 10001);
			ds.send(dp);//将数据进行发送
		}
		ds.close();//关闭资源
	}

}

class UDPRec2 {//定义一个接收端，用于存储接收端的方法
	public static void main(String[] args) throws Exception {
		//定义一个接收端端口，并指定接受的端口
		DatagramSocket ds = new DatagramSocket(10001);
		while (true) {
			//定义一个数据用于存储接受到的数据
			byte[] buf = new byte[1024];
			//定义一个数据包，用于存储接受到的数据
			DatagramPacket dp = new DatagramPacket(buf, buf.length);
            //建立开始接收的方法
			ds.receive(dp);
			//获取接收端的IP地址
			String ip = dp.getAddress().getHostAddress();
			//获取接受到的数据
			String data = new String(dp.getData(), 0, dp.getLength());
			//输出接受信息的IP地址及接收到的信息
			System.out.println(ip + "=" + data);
		}
	}

}

package javalianxi;

import java.net.DatagramPacket;//导入net包中的类包
import java.net.DatagramSocket;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 需求：
 * 定义一个应用程序，用于接受upd协议传输的数据并处理。
 * 思路：
 * 1.定义updsocket服务。通常会监听一个端口，其实就是给这个接受网络应用程序定义数字标识。
 *   方便于明确哪些数据过来改应用程序可以处理。
 * 2.定义一个数据包，因为要存储接受到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
 * 3.通过socket服务的receive方法将受到的数据存入已定义好的数据包中。
 * 4.通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上，
 * 5.关闭资源。
 * 
 */
public class UPDReceive {
	public static void main(String[] args) throws Exception
	{
		//1.创建udp soceket,建立端点。
		DatagramSocket ds=new DatagramSocket();
		while(true)
		{
		//2.定义数据包，用于存储数据。
		byte[] buf=new byte[1024];
		DatagramPacket dp=new DatagramPacket(buf,buf.length);
		
		//3.通过服务的receive方法将收到的数据存入数据包中。
		ds.receive(dp);
		
		//4.通过数据包的方法获取其中的数据。
		String ip=dp.getAddress().getHostAddress();
		String data=new String(dp.getData(),0,dp.getLength());
	
	    int port=dp.getPort();
	    System.out.println(ip+"::"+data+"::"+port);
	    
	    //5.关闭资源。
	    ds.close();
		}
	}

}

package javalianxi;

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 演示TCP传输。
 * 1.tcp分客户端和服务端。
 * 2.客户端对应的对象是Socket.
 *   服务端对应ServerSocket.
 */
/*
 * 客户端：
 * 通过查阅socket对象，发现在该对象建立时，就可以去连接制定主机。
 * 因为tcp是面向连接的，所以在建立socket服务时，就要有服务端存在，并连接成功，形成通路后，在该通道进行数据的传输。
 * 
 * 需求：给服务端发送一个文本数据。
 * 步骤：
 * 1.创建socket服务，并指定要连接的主机和端口。
 * 
 */
import java.io.InputStream;//导入IO流包中的类包
import java.io.OutputStream;
import java.net.ServerSocket;//导入net包中的类包
import java.net.Socket;

class TCPDemo {
	public static void main(String[] args) throws Exception {
		// 创建客户端的socket服务，制定目的的主机和端口。
		Socket s = new Socket("192.168.1.103", 10003);

		// 为了发送数据，应该获取socket流中的输出流。
		OutputStream out = s.getOutputStream();
		out.write("您好".getBytes());
		s.close();
	}

}
/*
 * 需求：定义端点接受数据并打印在控制台上。
 * 服务端：
 * 1.建立服务端的soceket服务，ServerSocket();
 *   并监听一个窗口。
 * 2.获取连接过来的客户端对象。
 *   通过ServerSocket的accept方法，没有连接就会等，所以这个方法是阻塞的。
 * 3.客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取该客户端对象的读取流来读取发过来的数据。
 * 4。关闭服务器。（可选） 
 */
class TCPServer
{
	public static void main(String[] args) throws Exception
	{
		 //建立服务端socket服务，并监听一个端口。
		ServerSocket ss=new ServerSocket(10003);
		Socket s=ss.accept();
		
		//通过accept方法获取连接过来的客户端对象。
		String ip=s.getInetAddress().getHostAddress();
		System.out.println(ip+"::::connected");
		
		//获取客户端发送过来的数据，那么服务端要使用客户端对象的读取流方法。
		InputStream in=s.getInputStream();
		
		byte[] buf=new byte[1024];
		int len=in.read(buf);
		System.out.println(new String(buf,0,len));
		
		//s.close();
		ss.close(); //关闭客户端。
	}
}

package javalianxi;
import java.io.InputStream;//导入IO流包中的类包
import java.io.OutputStream;
import java.net.ServerSocket;//导入net类包中的类包
import java.net.Socket;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 演示tcp传输的客户端和服务端的互访。
 * 需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。
 */
/*
 * 客户端：
 * 1.建立socket服务，指定要连接的主机和端口。
 * 2.获取socket流中的输出流，将数据写到该留中，通过网络发送给服务器。
 * 3.获取socket流中输入流，将服务端反馈的数据获取到，并打印。
 * 4.关闭客户端资源。
 */
class TCPDemo2 {//定义一个类用于定义发送方法
	public static void main(String[] args) throws Exception
	{
		//定义socket服务，并指定连接的主机和端口
		Socket s=new Socket("192.162.1.103",10004);
		//建立socket输出流，将数据写到该流中
		OutputStream out=s.getOutputStream();
		//将数据以字节的形式写入到流中
		out.write("服务端，您好".getBytes());
		//获取socket服务的输入流，获取服务端反馈的数据
		InputStream in=s.getInputStream();
		//定义一个数组用于存储读到的数据
		byte[] buf=new byte[1024];
		//将数据读到数组中
		int len=in.read(buf);
		//转换成字符串，并将数据打印出来
		System.out.println(new String(buf,0,len));
		s.close();//关闭端口
	}
}
class TCPServer2//定义一个类用于定义接收端方法
{
	public static void main(String[] args)throws Exception
	{
		//定义socket服务，并指定端口
		ServerSocket ss=new ServerSocket(10004);
		//端口开始接受数据
		Socket s=ss.accept();
		//获取到接受数据的主机名称
		String ip=s.getInetAddress().getHostAddress();
		//打印主机名称
		System.out.println(ip+"::::connected");
		//定义一个接收端读取流，将将接受到的数据进行读写
		InputStream in=s.getInputStream();
		//定义一个数组，用于存储读到的数据
		byte[] buf=new byte[1024];
		//将数据读到数组中
		int len=in.read(buf);
		//输出打印接受到的数据以字符串形式
		System.out.println(new String(buf,0,len));
		//建立一个接收端写入流
		OutputStream out=s.getOutputStream();
		//将收到信息反馈给发送端
		out.write("收到，您也好".getBytes());
		//关闭端口
		s.close();
		ss.close();
	}
}

package javalianxi;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 需求：建立一个文本转换服务器。
 * 客户端给服务端发送文本，服务端会将文本转成大写返给客户端。
 * 而且客户端可以不断的进行文本转换，当客户端输入over时，转换结束。
 * 
 * 分析：
 * 既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
 * 源：键盘录入。
 * 目的：网络设备，网络输出流。而且操作的是文本数据。可以选择字符流。
 * 而且操作的是文本数据，可以选择字符流。
 * 步骤：
 * 1.建立服务。
 * 2.获取键盘录入。
 * 3.将数据发给服务端。
 * 4.后去服务端返回的大写数据。
 */
import java.io.BufferedReader;//导入IO流包中的类包
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;//导入net包中的类包
import java.net.Socket;

class TCPLianxi {
	public static void main(String[] args) throws Exception { 
		Socket s = new Socket("192.168.1.103", 10005);
		// 定义读取键盘数据的流对象。
		BufferedReader bufr = new BufferedReader(new InputStreamReader(
				System.in));

		// 定义目的，将数据写入到socket输出流，发给服务端。
		BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(
				s.getOutputStream()));

		// 定义一个socket读取流，读取服务端返回的大写信息。
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(
				s.getInputStream()));

		String line = null;
		while ((line = bufr.readLine()) != null) {
			bufOut.write(line);
			if ("over".equals(line))
				break;
			bufOut.write(line);
			bufOut.newLine();
			bufOut.flush();
			String str = bufIn.readLine();
			System.out.println("server:" + str);
			bufr.close();
			s.close();
		}
	}
}

/*
 * 服务端： 源：socket读取流。 目的：socket输出流。 都是文本，装饰。
 */
class TransServer {
	public static void main(String[] args) throws Exception {
		ServerSocket ss = new ServerSocket(10005);
		Socket s = ss.accept();
		// 读取socket读取流中的数据。
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(
				s.getInputStream()));
		// 目的。socket输出流，将大写数据写入到socket输出流，并发送给客户端。
		BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(
				s.getOutputStream()));
		String line = null;
		while ((line = bufIn.readLine()) != null) {
			bufOut.write(line.toUpperCase());
			bufOut.newLine();
			bufOut.flush();
		}
		s.close();
		ss.close();
	}
}
/*
 * 该例子出现的问题。
 * 现象：客户端和服务端都在莫名的等待。
 * 为什么呢》
 * 因为客户端和服务端都有阻塞式方法，这些方法没有读到结束标记，那么就一直等而导致两端都在等待。
 * 
 */

package javaxuexi;

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 需求：上传图片。
 */
/*
 * 客户端：
 * 1.服务端点。
 * 2.读取客户端已有的图片数据。
 * 3.通过socket输出流将数据发给服务端。
 * 4.读取服务端反馈信息。
 * 5.关闭。
 */
import java.io.FileInputStream;//导入IO流包中的类包
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;//导入net包中的类包
import java.net.Socket;

class TCPPicture {// 定义一个类用于定义发送方法
	public static void main(String[] args) throws Exception {
		// 定义socket服务，并指定连接的主机和端口
		Socket s = new Socket("192.168.1.103", 10007);
		// 通过字节读取流读取一张图片
		FileInputStream fis = new FileInputStream("1.JPG");
		// 定义一个发送端写入流
		OutputStream out = s.getOutputStream();
		// 定义一个数组用于存储读到的数据，
		byte[] buf = new byte[1024];
		int len = 0;// 对数据进行读取
		while ((len = fis.read(buf)) != -1) {
			out.write(buf, 0, len);// 写入数据，从什么开始，长度
		}

		// 告诉服务端数据已写完。
		s.shutdownOutput();
		// 定义一个读取流读取接收端反馈的信息
		InputStream in = s.getInputStream();
		// 定义一个数组用于存储读到反馈的数据
		byte[] bufIn = new byte[1024];
		// 将反馈的数据读到数组中
		int num = in.read(bufIn);
		// 输出打印读到的信息
		System.out.println(new String(bufIn, 0, num));
		// 关闭端口
		fis.close();
		s.close();
	}
}

/*
 * 服务端: 这个服务端有个局限性,当A客户端连接上以后，被服务端获取到，服务端执行具体流程。 这时B客户端连接 ，只有等待。
 * 因为服务端还没有处理完A客户端的请求，还有玄幻回来执行下次accept方法，所以暂时获取不到B客户端对象。 那么为了可以让多个客户端同时并发访问服务端。
 * 那么服务端最好就是将每个客户端封装到一个单独的线程中，这样，就 可以同时处理多个客户端请求。
 * 
 * 只要明确了每一个客户端要在服务端执行的代码即可，将该代码存入run方法中。
 */
class TCPPicture1 {// 定义一个类用于定义发送方法
	public static void main(String[] args) throws Exception {
		// 定义socket服务，并指定连接的端口
		ServerSocket ss = new ServerSocket(10007);
		// 端口开始接受数据
		Socket s = ss.accept();
		// 通过字节读取流对接受到的数据进行读取
		InputStream in = s.getInputStream();
		// 定义一个图片用于存储读取到的数据
		FileOutputStream fos = new FileOutputStream("2.JPG");
		// 定义一个数组用于存储读到的数据
		byte[] buf = new byte[1024];
		int len = 0;
		// 对数据进行读取
		while ((len = in.read(buf)) != -1) {
			fos.write(buf, 0, len);// 将读到的数据写入到图片中
		}
		// 将读到的信息进行反馈
		OutputStream out = s.getOutputStream();
		// 通过写入流将反馈信息发送出去
		out.write("上传成功".getBytes());
		// 关闭流资源
		fos.close();
		// 关闭端口
		s.close();
		ss.close();
	}

}