UDP编程：拷贝图片

标题：UDP编程：拷贝图片

1.UDP编程的步骤：
1>发送端：

• 1.使用DatagramSocket
• 2.准备数据
• 3.封装成DatagramPacket包裹,需指定目的地
• 4.释放资源 若是多线程，则最后释放资源
  2>接收端：
• 1.使用DatagramSocket
• 2.准备容器 封装成DatagramPacket包裹
• 3.阻塞式接收包裹
• 4.分析数据
• 5.释放资源 若是多线程，则最后释放资源

2.提示：只要能转成字节数组，就能通过while不断地发送；

3.过程分析:
1）方式一；发送端通过while不断写入字节数组【大小为buf.length】，发送，直到循环结束，退出即可

        BufferedInputStream is=new BufferedInputStream(new FileInputStream(file));
		int len=0;
		byte[] buf=new byte[6];
		while((len=is.read(buf))!=-1) {

2）方式二：将文件读取后，直接通过流全部写入字节数组，再发送，适用于较小的文件

ByteArrayOutputStream baos=new BytearrayOutputStream();
BufferedOutputStream os=new BufferedOutputStream(baos)

1>方式一：发送端通过while不断写入字节数组【大小为buf.length】，发送，直到循环结束，退出即可
注意：接收端何时while循环结束，使用的是，判断dp.getLength()<6
“6”,为发送端每回发送的长度，接收完<6的数据后，将所有的数据接收完毕，即可退出while循环

while(flag) {
	dp=new DatagramPacket(buf,0,buf.length);//Client发送一个包裹，此处就准备一次包裹进行接收
	ds.receive(dp);	
	os.write(buf,0,dp.getLength());  
	os.flush();//没有刷新，因为没有达到8k的缓冲容量，故不会输出到文件
	System.out.print("接收的内容为：-->"+new String(buf,0,dp.getLength()));
	if(dp.getLength()<6) {
		break;
	}
}

发送端完整代码如下：

//测试发送图片  //只要能转成字节数组，就能通过while不断地发送
/**
 * 1.使用DatagramSocket 
 * 2.准备数据
 * 3.封装成DatagramPacket包裹,需指定目的地
 * 4.释放资源  若是多线程，则最后释放资源
 * @author dell
 *
 */
public class TestUDPClient02 {
	public static void main(String[] args) throws Exception {
		System.out.println("-------Client---------");
		 //1.使用DatagramSocket 
		DatagramSocket ds=new DatagramSocket(6666);
		// 2.准备数据
		//2.1创建源
		File file=new File("E:/eclipse/crazy/src/com/sxt/net/udp/aaa.txt");
//		File file=new File("E:/eclipse/crazy/src/com/sxt/net/udp/球.jpg");

		//2.2选择流
		//2.3操作
		BufferedInputStream is=new BufferedInputStream(new FileInputStream(file));
		int len=0;
		byte[] buf=new byte[6];
		while((len=is.read(buf))!=-1) {
			//3.封装成DatagramPacket包裹,需指定目的地
			DatagramPacket dp=new DatagramPacket(buf,len,InetAddress.getByName("localhost"),8888); 
			ds.send(dp);	
			System.out.print("发送的内容为：-->"+new String(buf,0,len));
		}
		//3.4关闭
		is.close();
		System.out.println("发送成功");
		//* 4.释放资源  若是多线程，则最后释放资源
		ds.close();
	}
}

接收端完整代码如下：

/**
 * 1.使用DatagramSocket 
 * 2.准备容器   封装成DatagramPacket包裹
 * 3.阻塞式接收包裹  
 * 4.分析数据
 * 5.释放资源  若是多线程，则最后释放资源
 * @author dell
 *
 */
public class TestUDPServer02 {
	public static void main(String[] args) throws Exception {
		System.out.println("-------Server---------");
		 //1.使用DatagramSocket 
		DatagramSocket ds=new DatagramSocket(8888);
		// 2.准备容器   封装成DatagramPacket包裹
		byte[] buf=new byte[1024*60];//接受的若大于此数组大小，problem-->发送端固定了大小，接收端使用该大小
		 
		//3.阻塞式接收包裹
		//3.1创建源
		File file=new File("E:/eclipse/crazy/src/com/sxt/net/udp/aaaCopy.txt");
//		File file=new File("E:/eclipse/crazy/src/com/sxt/net/udp/球Copy.jpg");
		//3.2选择流
		BufferedOutputStream os=new BufferedOutputStream(new FileOutputStream(file));
		//3.3操作
		//3.4关闭
		boolean flag=true;
		DatagramPacket dp=null;
		while(flag) {
			dp=new DatagramPacket(buf,0,buf.length);//Client发送一个包裹，此处就准备一次包裹进行接收
			ds.receive(dp);	//1）接收，放到buf中，再次接收； 2）放到0,buf.length
			os.write(buf,0,dp.getLength());   //第二次接收，是从头开始？还是继续后面的
			os.flush();//没有刷新，因为没有达到8k的缓冲容量，故不会输出到文件
			System.out.print("接收的内容为：-->"+new String(buf,0,dp.getLength()));
			if(dp.getLength()<6) {
				break;
			}
		}
		//4.分析数据
//		System.out.println(dp.getLength());
		System.out.println(new String(buf,0,dp.getLength()));
		System.out.println("接收完毕");
		//5.释放资源  若是多线程，则最后释放资源
		ds.close();
	}
}

2>方式2：将文件读取后，直接通过流全部写入字节数组，再发送，适用于较小的文件
发送端：

//方式二
//测试发送图片  //只要能转成字节数组，就能通过while不断地发送
//方式一；通过while不断地发送，接收
//方式二：直接将图片转成字节数组，发送，接收端一次性接收  适用于较小的
/**
 * 1.使用DatagramSocket 
 * 2.准备数据
 * 3.封装成DatagramPacket包裹,需指定目的地
 * 4.释放资源  若是多线程，则最后释放资源
 * @author dell
 *
 */
public class TestUDPClient022 {
	public static void main(String[] args) throws Exception {
		System.out.println("-------Client---------");
		 //1.使用DatagramSocket 
		DatagramSocket ds=new DatagramSocket(6666);
		// 2.准备数据
		//2.1创建源
//		File file=new File("E:/eclipse/crazy/src/com/sxt/net/udp/aaa.txt");
		File file=new File("E:/eclipse/crazy/src/com/sxt/net/udp/球.jpg");

		//2.2选择流
		//2.3操作
		BufferedInputStream is=new BufferedInputStream(new FileInputStream(file));
		ByteArrayOutputStream baos=new ByteArrayOutputStream();
		BufferedOutputStream bos=new BufferedOutputStream(baos);

		int len=0;
		byte[] buf=new byte[6];
		while((len=is.read(buf))!=-1) {
			bos.write(buf,0,len);
		}
		bos.flush();
		byte[] buf2=baos.toByteArray();
		//3.封装成DatagramPacket包裹,需指定目的地
		DatagramPacket dp=new DatagramPacket(buf2,buf2.length,InetAddress.getByName("localhost"),8888); 
		ds.send(dp);	
		//3.4关闭
		bos.close();
		is.close();
		System.out.println("发送成功");
		//* 4.释放资源  若是多线程，则最后释放资源
		ds.close();
	}
}

接收端：

//方式二
//测试发送图片  //只要能转成字节数组，就能通过while不断地发送
//方式一；通过while不断地发送，接收
//方式二：直接将图片转成字节数组，发送，接收端一次性接收  适用于较小的
/**
 * 1.使用DatagramSocket 
 * 2.准备容器   封装成DatagramPacket包裹
 * 3.阻塞式接收包裹  
 * 4.分析数据
 * 5.释放资源  若是多线程，则最后释放资源
 * @author dell
 *
 */
public class TestUDPServer022 {
	public static void main(String[] args) throws Exception {
		System.out.println("-------Server---------");
		 //1.使用DatagramSocket 
		DatagramSocket ds=new DatagramSocket(8888);
		// 2.准备容器   封装成DatagramPacket包裹
		byte[] buf=new byte[1024*60];//接受的若大于此数组大小，problem-->发送端固定了大小，接收端使用该大小
		 
		//3.阻塞式接收包裹
		//3.1创建源
//		File file=new File("E:/eclipse/crazy/src/com/sxt/net/udp/aaaCopy.txt");
		File file=new File("E:/eclipse/crazy/src/com/sxt/net/udp/球Copy.jpg");
		//3.2选择流
		BufferedOutputStream os=new BufferedOutputStream(new FileOutputStream(file));
		//3.3操作
		//3.4关闭
		DatagramPacket dp=new DatagramPacket(buf,0,buf.length);//Client发送一个包裹，此处就准备一次包裹进行接收
		ds.receive(dp);	//1）接收，放到buf中，再次接收； 2）放到0,buf.length
		os.write(buf,0,dp.getLength());   //第二次接收，是从头开始？还是继续后面的
		os.flush();//没有刷新，因为没有达到8k的缓冲容量，故不会输出到文件
		//4.分析数据
//		System.out.println(dp.getLength());
		System.out.println(new String(buf,0,dp.getLength()));
		System.out.println("接收完毕");
		//5.释放资源  若是多线程，则最后释放资源
		ds.close();
	}
}