[关闭]
@w460461339 2016-11-16T07:10:15.000000Z 字数 10116 阅读 744

Java学习Day15（网络编程 UDP/TCP）

Java基础

今天，哦不，是这几天断断续续把Java的网络编程给学习了= - 效率太低了。Anyway，开始吧。

1、网络编程概述

1.1网络编程层级关系

一共有七层，从上到下分别为：

应用层
表示层
会话层
传输层
网络层
数据链入口层
物理层

我们主要是在应用层层面进行编程。

1.2网络通信三要素

网络通信主要有三要素，分别为：IP地址，端口号以及协议。
IP地址是在网络中确认电脑的唯一地址，它帮助我们找到电脑；
端口号是应用程序在该电脑上的地址，它帮助我们在某电脑上找到特定的应用程序；
协议则是传输数据的方式，帮助我们的应用程序确认以哪种方式来理解数据。

1.2.1IP地址

网络中计算机的唯一标识。

计算机只能识别二进制的数据，所以我们的IP地址应该是一个二进制的数据。
但是呢，我们配置的IP地址确不是二进制的，为什么呢?
IP：192.168.1.100
换算：11000000 10101000 00000001 01100100
假如真是：11000000 10101000 00000001 01100100的话。
我们如果每次再上课的时候要配置该IP地址，记忆起来就比较的麻烦。
所以，为了方便表示IP地址，我们就把IP地址的每一个字节上的数据换算成十进制，然后用.分开来表示：
"点分十进制"

IP地址的组成：网络号段+主机号段
A类：第一号段为网络号段+后三段的主机号段
一个网络号：256*256*256 = 16777216
B类：前二号段为网络号段+后二段的主机号段
一个网络号：256*256 = 65536
C类：前三号段为网络号段+后一段的主机号段
一个网络号：256

IP地址的分类：
A类 1.0.0.1---127.255.255.254 (1)10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址) (2)127.X.X.X是保留地址，用做循环测试用的。
B类 128.0.0.1---191.255.255.254 172.16.0.0---172.31.255.255是私有地址。169.254.X.X是保留地址。
C类 192.0.0.1---223.255.255.254 192.168.X.X是私有地址
D类 224.0.0.1---239.255.255.254
E类 240.0.0.1---247.255.255.254

两个DOS命令：
ipconfig 查看本机ip地址
ping 后面跟ip地址。测试本机与指定的ip地址间的通信是否有问题

特殊的IP地址：
127.0.0.1 回环地址(表示本机)
x.x.x.255 广播地址
x.x.x.0 网络地址

InetAddress获取本机IP地址

  1. import java.io.IOException;
  2. import java.net.InetAddress;
  4. public class MyInetDemo {
  6.     /**
  7.      * @param args
  8.      */
  9.     public static void main(String[] args) throws IOException{
  10.         //以主机名字获取其InetAddress对象。
  11.         //注意，它没有构造方法，也不是单一实例模式
  12.         //仅能通过调用它的静态方法来创建它的实例
  13.         InetAddress id=InetAddress.getByName("WuZifan");
  15.         //获取主机的名字
  16.         String name=id.getHostName();
  18.         //获取主机IP地址
  19.         String ipadd=id.getHostAddress();
  21.         //输出
  22.         System.out.println(name+"--"+ipadd);
  23.     }
  24. }
1.2.2端口号

正在运行的程序的标识。
有效端口：0~65535，其中0~1024系统使用或保留端口。

1.2.3协议

通信的规则

UDP：
    把数据打包
    数据有限制
    不建立连接
    速度快
    不可靠

TCP：
    建立连接通道
    数据无限制
    速度慢
    可靠

举例：
    UDP：发短信
    TCP：打电话

2、UDP协议发送数据

首先，想清楚发送和接收数据需要确认的内容：

数据以及数据长度
IP地址以及端口号

在UDP中，发送和接收都需要通过DatagraSocket来进行（相当于电台）；而数据都需要通过DatagramPacket来打包（相当于信封）。

2.1 基本发送功能实现

为了方便理解，先写发送端
发送端

  1. package net_02;
  3. import java.io.IOException;
  4. import java.net.DatagramPacket;
  5. import java.net.DatagramSocket;
  6. import java.net.InetAddress;
  8. public class MyUDPSend {
  9.                     //要抛IOEception
  10.     public static void main(String[] args) throws IOException{
  11.         //创建UDP的Socket对象
  12.         DatagramSocket ds=new DatagramSocket();
  14.         //封装要打包的数据
  15.         //用这条语句：DatagramPacket(byte[] buf, int length, InetAddress address, int port) 
  16.         //要打包的数据
  17.         byte[] bys="hello,world".getBytes();
  19.         //获取长度
  20.         int len=bys.length;
  22.         //封装目标主机的IP
  23.         InetAddress id=InetAddress.getByName("WuZifan");
  25.         //封装端口
  26.         int port=22222;
  28.         //创建DatagramPacket对象
  29.         DatagramPacket dp=new DatagramPacket(bys, len, id, port);
  31.         //发送数据
  32.         ds.send(dp);
  34.         //关闭
  35.         ds.close();
  36.     }
  37. }

接收端

  1. package net_02;
  3. import java.io.IOException;
  4. import java.net.DatagramPacket;
  5. import java.net.DatagramSocket;
  7. public class MyUDPRec {
  9.     public static void main(String[] args)throws IOException {
  10.         //创建接收的Socket对象,并指定端口(这里和发送端不一样了！)
  11.         DatagramSocket ds=new DatagramSocket(22222);
  13.         //创建接收的Datagrampacket对象
  14.         byte[] bys=new byte[1024];
  15.         int len=bys.length;
  16.         DatagramPacket dp=new DatagramPacket(bys, len);
  18.         //接收数据
  19.         //注意此时数据并不会放到之前的bys和len中，需要另外创建
  20.         //字节数组和int变量，通过getData和getLength方法啦获得
  21.         ds.receive(dp);
  23.         //显示数据
  24.         byte[] buf=dp.getData();
  25.         int length=dp.getLength();
  26.         String data=new String(buf,0,length);
  27.         System.out.println(data);
  29.         //关闭
  30.         ds.close();
  31.     }
  32. }
2.2 基于多线程的聊天室

基本思想使用线程将发送和接收端封装，使得可以进行持续的发送和接收
测试类

  1. package net_05;
  3. import java.io.IOException;
  4. import java.net.DatagramSocket;
  6. public class MyChat {
  8.     /**
  9.      * 任务：
  10.      *      创建聊天室
  11.      * 实现：
  12.      *      创建发送端和接收端的datagramsocket对象
  13.      *      创建多线程
  14.      *      打开多线程
  15.      */
  16.     public static void main(String[] args) throws IOException{
  17.         //创建datagramsocket对象
  18.         //注意这里传给dsReve的端口号要和st里面的端口号一样
  19.         DatagramSocket dsSend=new DatagramSocket();
  20.         DatagramSocket dsReve=new DatagramSocket(22222);
  22.         //创建多线程
  23.         SendThread st=new SendThread(dsSend);
  24.         ReveThread rt=new ReveThread(dsReve);
  26.         Thread send=new Thread(st);
  27.         Thread reve=new Thread(rt);
  28.         //打开线程      
  29.         send.start();
  30.         reve.start();
  31.     }
  32. }

发送端

  1. package net_05;
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  5. import java.net.InetAddress;
  6. import java.util.Scanner;
  8. public class SendThread implements Runnable{
  9.     //创建发送端DatagramSocket对象
  10.     private DatagramSocket ds;
  11.     public SendThread(DatagramSocket ds){
  12.         this.ds=ds;
  13.     }
  14.     //多线程要运行的程序
  15.     @Override
  16.     public void run() {
  17.         //从键盘录入数据，并为打包进DatagramPacket做准备
  18.         Scanner in=new Scanner(System.in);
  19.         byte[] bys=new byte[1024];
  20.         int len=0;
  22.         while(true){
  23.         //这里选择利用try-catch来处理异常
  24.             try{
  25.                 String str=in.nextLine();
  26.         //自定义结束符号
  27.                 if(str.equals("bye")){
  28.                     break;
  29.                 }else{
  30.                 //读取数据以及长度
  31.                     bys=str.getBytes();
  32.                     len=bys.length;
  33.                 //打包
  34.                     DatagramPacket dp=new DatagramPacket(bys, len, 
  35.                            InetAddress.getByName("WuZifan"),22222);
  36.                 //发送
  37.                     ds.send(dp);
  38.                 }
  39.             }catch(Exception e){
  40.                 e.printStackTrace();
  41.             }
  42.         }
  43.         //注意这个关闭要放在while外面
  44.         ds.close();
  45.     }
  46. }

接收端

  1. package net_05;
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  6. public class ReveThread implements Runnable{
  7.     //创建接收端DatagramSocket对象
  8.     private DatagramSocket ds;
  9.     public ReveThread(DatagramSocket ds){
  10.         this.ds=ds;
  11.     }
  13.     @Override
  14.     public void run() {
  15.     //创建接收端接收数据需要的包
  16.         byte[] bys=new byte[1024];
  17.         int len=bys.length;
  18.         DatagramPacket dp=new DatagramPacket(bys, len);
  19.         while(true){
  20.             try{
  21.             //获取数据包
  22.             ds.receive(dp);
  23.             //获取数据以及长度，并转为String
  24.             byte[] bys2=dp.getData();
  25.             int len2=dp.getLength();
  26.             String str=new String(bys2, 0, len2);
  27.             //输出发送主机名以及数据
  28.             System.out.println(dp.getAddress().getHostName()+"--"+str);
  29.             }catch(Exception e){
  30.                 e.printStackTrace();
  31.             }
  32.         }
  33.     }   
  34. }

这里需要注意的一点是，因为接收端不会关闭，所以在运行测试类的时候，哪怕输入了bye这个自定义结束符号，测试类也不会关闭，因为接收端的线程还在一直开启。

3、ICP协议发送数据

ICP和UDP除了是否需要确定接收以外，在代码层面上最大的不同就是，UDP利用DatagramPacket封装了数据，并直接利用DatagramSocket的send和receive方法来封装了发送和接收的方法，让我们不知道底层是什么；而ICP则很明确的告诉我们，他们是利用IO流来进行数据传输的。
这次我们先写发送端

3.1 ICP协议发送数据基本功能

发送端

  1. package net_03;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  10. public class MyICPServer {
  12.     /**
  13.      * 服务器端创建步骤：
  14.      *      A：创建服务器端Socket对象（seversocket）
  15.      *      B：获取输入流，输出
  16.      *      C：关闭
  17.      */
  18.     public static void main(String[] args)throws IOException {
  19.         // TODO Auto-generated method stub
  20.         //创建服务器端socket对象
  21.         ServerSocket ss=new ServerSocket(22222);
  22.         //事件监听，在这一步程序阻塞，直到有数据传来
  23.         Socket sk=ss.accept();
  25.         //获取输入流，这里用高效的字符流获取
  26.         BufferedReader br=new BufferedReader(new InputStreamReader(sk.getInputStream()));
  27.         String str=br.readLine();
  28.         System.out.println(str);
  29.         //字节流接收并打印到控制台
  30.         //byte[] bys=new byte[1024];
  31.         //int len=0;
  32.         //InputStream is=sk.getInputStream();
  33.         //len=is.read(bys);
  34.         //String str=new String(bys,0,len);
  35.         //System.out.println(str);
  37.         //关闭
  38.         ss.close();
  39.     }
  40. }

客户端

  1. package net_03;
  3. import java.io.BufferedWriter;
  4. import java.io.IOException;
  5. import java.io.OutputStream;
  6. import java.io.OutputStreamWriter;
  7. import java.net.InetAddress;
  8. import java.net.Socket;
  10. public class MyICPClient {
  12.     /**
  13.      * 客户端创建步骤：
  14.      *      A：创建发送端的Socket对象
  15.      *      B：获取输出流，写入数据
  16.      *      C：释放资源
  17.      */
  18.     public static void main(String[] args)  throws IOException {
  19.         // TODO Auto-generated method stub
  20.         //创建发送端Socket对象，指定IP，以及端口号
  21.         InetAddress id=InetAddress.getByName("WuZifan");
  22.         Socket sc=new Socket(id,22222);
  24.         //获取输出流对象（这里用高效的字符流接收）
  25.         //创建方式：高效字符流对象=高效字符流（字符字节转换流（字节流））
  26.         BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(sc.getOutputStream())); 
  27.         //写入数据
  28.         bw.write("Hello,ICP");
  29.         bw.flush();//这个刷新一定不要忘了，不然就读不到了= - 
  30.         //字节流方法写入数据
  31.         //OutputStream os=sc.getOutputStream();
  32.         //os.write("hello,ICP".getBytes());
  33.         //关闭，因为bw依赖sc，直接关闭sc就好
  34.         sc.close();
  35.     }
  36. }
3.2 ICP协议发送数据之客户端键盘录入

这里的关键是如何处理多次录入的多条数据；在客户端较好解决，添加自定义结束字符，每次一行行的发送就好；在客户端，也是每次一行行读即可。

但是需要理解这个，就需要理解两个阻塞式方法，一个是ServerSocket的accept方法，一个就是字符/字节流的read或者readLine方法。accept()阻塞是为了等待连接信号，一旦连通了，就往下走；read()或者readLine()阻塞是为了等待数据的进入，一旦有数据进来，程序就往下走。

就是这样
客户端

  1. package net_04;
  3. import java.io.BufferedWriter;
  4. import java.io.IOException;
  5. import java.io.OutputStreamWriter;
  6. import java.net.InetAddress;
  7. import java.net.Socket;
  8. import java.util.Scanner;
  10. public class MyICPClient {
  11.     public static void main(String[] args) throws IOException{
  12.         //创建客户端Socket对象
  13.         Socket sk=new Socket(InetAddress.getByName("WuZifan"),
  14.                                                         22222);
  15.         //键盘输入
  16.         Scanner in=new Scanner(System.in);
  17.         //封装输入流
  18.         BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(sk.getOutputStream()));
  19.         String str=null;
  20.         //持续输入数据
  21.         while(true){
  22.             str=in.nextLine();
  23.         //直到输入bye时停止输入
  24.             if(str.equals("bye")){
  25.                 break;
  26.             }else{
  27.         //注意write，newLine以及flush，三者缺一不可。
  28.                 bw.write(str);
  29.                 bw.newLine();
  30.                 bw.flush();
  31.             }
  32.         }
  33.         //关闭
  34.         sk.close();
  35.     }
  36. }

服务器

  1. package net_04;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.net.ServerSocket;
  7. import java.net.Socket;
  9. public class MyICPServer {
  10.     public static void main(String[] args) throws IOException{
  11.         //创建服务器端Socket对象
  12.         ServerSocket ss=new ServerSocket(22222);
  13.         //监听
  14.         //阻塞式方法，这个方法判断是否有客户端连接
  15.         //一旦连接上，就往下继续进行（连接上和有数据过来是两个概念）
  16.         Socket sk=ss.accept();
  17.         //封装输入数据
  18.         BufferedReader br=new BufferedReader(new InputStreamReader(sk.getInputStream()));
  19.         String str=null;
  20.         //这个readLine或者read在这里都是阻塞式方法
  21.         //在没有数据过来时一直停着，当数据过来后才继续往下
  22.         //当客户端输入bye时，没有数据继续录入，传入一个空行，结束
  23.         while((str=br.readLine())!=null){
  24.                 System.out.println(str);
  25.         }
  26.         //关闭
  27.         sk.close();
  28.     }
  29. }
3.3 上传图片+反馈

上传文件需要注意的有两点：

1、最后记得刷新，以免数据丢失
2、记得shutdown输出流，告诉服务器上传结束

反馈主要就是服务器通过输入流写入，客户端通过输出流读取
客户端

  1. package net_06;
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.BufferedReader;
  6. import java.io.FileInputStream;
  7. import java.io.IOException;
  8. import java.io.InputStreamReader;
  9. import java.net.InetAddress;
  10. import java.net.Socket;
  12. public class MyClientDemoR {
  14.     /**
  15.      * @param args
  16.      */
  17.     public static void main(String[] args) throws IOException{
  18.         //创建客户端处Socket对象
  19.         Socket sk=new Socket(InetAddress.getByName("WuZifan"), 22222);
  20.         //获取输出流
  21.         BufferedOutputStream bis=new BufferedOutputStream(sk.getOutputStream());
  22.         //获取图片文件，并写入（这个需要再复习一下啊）
  23.         //FileinputStream是InputStream的子类
  24.         BufferedInputStream mypic=new BufferedInputStream(new FileInputStream("my.jpg"));
  25.         byte[] bys=new byte[1024];
  26.         int len=0;
  27.         while((len=mypic.read(bys))!=-1){
  28.             bis.write(bys,0,len);
  29.         }
  30.         //当之前读入到最后时，还有一部分数据在缓冲区，没有刷进流中
  31.         //需要强制刷新一下，让最后的数据进入流
  32.         bis.flush();
  33.         //在读入数据时可以通过len是否为-1来判断读入是否结束
  34.         //但在服务器端接收时却无法读到这个最后的信息。需要人为给一个信息，告诉服务器端我读完了
  35.         //通过shutdown方法来告诉服务器，上传完成了
  36.         sk.shutdownOutput();
  38.         //获取输入流，并显示反馈
  39.         BufferedReader br=new BufferedReader(new InputStreamReader(sk.getInputStream()));
  40.         String str=br.readLine();//阻塞式
  41.         System.out.println(str);
  43.         //关闭
  44.         mypic.close();
  45.         sk.close();
  46.     }
  47. }

服务器

  1. package net_06;
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.BufferedWriter;
  6. import java.io.FileOutputStream;
  7. import java.io.IOException;
  8. import java.io.OutputStreamWriter;
  9. import java.net.ServerSocket;
  10. import java.net.Socket;
  12. public class MySeverDemoR {
  14.     /**
  15.      * @param args
  16.      */
  17.     public static void main(String[] args) throws IOException {
  18.         //创建服务器端Socket对象
  19.         ServerSocket ss=new ServerSocket(22222);
  20.         Socket sk=ss.accept();
  21.         //创建被输出对象（多复习啊！！）
  22.         BufferedOutputStream newpic=new BufferedOutputStream(new FileOutputStream("new.jpg"));
  23.         //获取输入流，并显示
  24.         BufferedInputStream bis=new BufferedInputStream(sk.getInputStream());
  25.         //读取，并写入文件
  26.         byte[] bys=new byte[1024];
  27.         int len=0;
  28.         while((len=bis.read(bys))!=-1){//结束标志是-1，不是0！
  29.             newpic.write(bys, 0, len);
  30.         }
  31.         //获取输出流，并给与回馈
  32.         BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(sk.getOutputStream()));
  33.         bw.write("收到了");
  34.         bw.newLine();
  35.         bw.flush();
  36.         //关闭    
  37.         newpic.close();
  38.         sk.close();
  39.     }
  40. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注