• 黑马程序员——网络编程



     

    网络编程

    1、网络参考模型

      网络参考模型是控制网络的规范,所有的公司使用这个相同的规范来控制网络,就能互联了。最流行的参考模型有:OSI参考模型和TCP/IP参考模型。

      两种网络参考模型的结构示意图如下:

      

      网络中的数据通信是通过层与层之间封包、解封包的过程。

      

      A机器的数据经过逐层封装,传到B机器,再经过逐层解封,B拿到了最终传输的数据。

      OSI参考模型虽然设计精细,但过于麻烦,效率不高,因此才产生了简化版的TCP/IP参考模型。

    2、网络通讯要素

      网络通讯有三要素:IP地址,端口号,传输协议

      一、IP地址,对应java中的InetAddress类。

        1、ip地址是网络中设备的标识。不易记忆,可用主机名。

        2、在没有连接互联网的情况,为了让访问本机方便,所以分配了一个默认的IP地址,也就是本地回环。本地回环地址:127.0.0.1 主机名:localhost。

        3、通过ping 127.0.0.1可以测试网络是不是通,如果不通,可能是网卡出问题了。

        InetAddress类无构造函数,可通过getLocalHost()方法获取InetAddress对象,此方法是静态的,返回本类对象。

                      InetAddress i = InetAddress.getLocalHost();

          常用方法:

                    1)static InetAddress getByName(String host):获取指定主机的IP和主机名。(最好用ip地址去获取,主机名需要解析)

                    2)static InetAddress[] getAllByName(String host):在给定主机名的情况下,根据系统上配置的名称服务返回IP地址所组成的数组。返回对象不唯一时,用此方法。

                    3)String getHostAddress():返回IP地址字符串文本形式,以IP地址为主。

                    4)String getHostName():返回IP地址主机名。

      二、端口号

        端口号:用于标识进程(应用程序)的逻辑地址,不同进程的标识。有效端口:0~65535,其中0~1024系统使用或保留端口。

      三、传输协议

        传输协议就是通讯的规则。常见协议:UDP、TCP。

        UDP:

          1、将数据及源和目的封装成数据包中,不需要建立连接。

          2、每个数据报的大小在限制在64k内。

          3、因无连接,是不可靠协议。

          4、不需要建立连接,速度快。

          应用案例:QQ、FeiQ聊天、在线视频用的都是UDP传输协议。

        TCP:

          1、建立连接,形成传输数据的通道。

          2、在连接中进行大数据量传输。

          3、通过三次握手完成连接,是可靠协议

          4、必须建立连接,效率会稍低。

          应用案例:FTP,File Transfer Protocol(文件传输协议) 。

      关于域名解析的小知识:域名解析,最先走是本地的hosts(C:WINDOWSsystem32driversetchosts)文件,解析失败了,才去访问DNS服务器解析、获取IP地址。通过hosts文件可以屏蔽垃圾网站内容弹出,例如:在hosts文件中添加,127.0.0.1 www.game18.com。

      Socket就是为网络服务提供的一种机制。通信的两端都有Socket。网络通信其实就是Socket间的通信。数据在两个Socket间通过IO传输。

    3、UDP协议

      ①:只要是网络传输,必须有socket 。

      ②:数据一定要封装到数据包中,数据包中包括目的地址、端口、数据等信息。

      直接操作UDP很复杂,java语言将UDP封装成对象,易于我们的使用,这个对象就是DatagramSocket. 封装了UDP传输协议的socket对象。 因为数据包中包含的信息较多,为了操作这些信息方便,也一样会将其封装成对象。这个数据包对象就是:DatagramPacket.通过这个对象中的方法,就可以获取到数据包中的各种信息。 DatagramSocket具备发送和接受功能,在进行UDP传输时,需要明确一个是发送端,一个是接收端。

      UDP的发送端:

        ①:建立udp的socket服务,创建对象时如果没有明确端口,系统会自动分配一个未被使用的端口。

        ②:明确要发送的具体数据。

        ③:将数据封装成了数据包。

        ④:用socket服务的send方法将数据包发送出去。

        ⑤:关闭资源。

      UDP的接收端:

        ①:创建udp的socket服务,必须要明确一个端口,作用在于,只有发送到这个端口的数据才是这个接收端可以处理的数据。

        ②:定义数据包,用于存储接收到数据。

        ③:通过socket服务的接收方法将收到的数据存储到数据包中。

        ④:通过数据包的方法获取数据包中的具体数据内容,比如ip、端口、数据等等。

        ⑤:关闭资源。

     1 import java.net.*;
     2 //UDP发送端
     3 class UDPDemoSend 
     4 {
     5     public static void main(String[] args) throws Exception
     6     {
     7         
     8         System.out.println("发送端启动!");
     9         DatagramSocket ds=new DatagramSocket();//创建UDP服务
    10         String str="Hello!UDP";
    11         //构建数据包
    12         DatagramPacket dp=new DatagramPacket(str.getBytes(),str.length(),InetAddress.getByName("192.168.1.103"),10000);
    13         //发送数据包
    14         ds.send(dp);
    15         //关闭socket服务
    16         ds.close();
    17     }
    18 }
    19 //UDP接收端
    20 class UDPDemoReceive 
    21 {
    22     public static void main(String[] args) throws Exception
    23     {
    24         System.out.println("接收端启动!");
    25         DatagramSocket ds=new DatagramSocket(10000);//创建UDP服务,接收端要指定端口
    26         byte[] buf=new byte[1024];
    27         DatagramPacket dp=new DatagramPacket(buf,buf.length);//创建数据包,接收端不用指定具体的接收端信息
    28         ds.receive(dp);//接收数据。
    29         String ip=dp.getAddress().getHostAddress();//获取IP
    30         int port =dp.getPort();//获取端口
    31         String data=new String(dp.getData(),0,dp.getLength());//获取数据
    32         System.out.println(ip+":"+port+":"+data);
    33         ds.close();//关闭数据流
    34     }
    35 }

    运行结果如图所示:

      由于UDP协议传输数据,只管发送数据,而不管接收端是否能够接收到数据。因此,应该首先启动接收端程序,再启动发送端程序。

      下面写一个复杂一点的UDP程序,通过线程来做接收和发送,在同一个窗口中实现聊天。

     1 import java.net.*;
     2 import java.io.*;
     3 //发送线程
     4 class UDPSend implements Runnable
     5 {
     6     private DatagramSocket ds;
     7     UDPSend(DatagramSocket ds)
     8     {
     9         this.ds=ds;
    10     }
    11     public void run()
    12     {
    13         DatagramPacket dp=null;
    14         try
    15         {
    16             //创建控制台录入的流
    17             BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    18             for(String line=null;(line=br.readLine())!=null;)
    19             {
    20                 //创建发送的数据包
    21                 dp=new DatagramPacket(line.getBytes(),line.length(),InetAddress.getByName("192.168.1.103"),10001);
    22                 ds.send(dp);
    23                 if(line.equals("886"))
    24                     break;
    25             }
    26             br.close();
    27             ds.close();//记得关流
    28         }
    29         catch (Exception e)
    30         {
    31             throw new RuntimeException();
    32         }
    33         
    34     }
    35 }
    36 //接收线程
    37 class UDPReceive implements Runnable
    38 {
    39     private DatagramSocket ds;
    40     UDPReceive(DatagramSocket ds)
    41     {
    42         this.ds=ds;
    43     }
    44     public void run()
    45     {
    46         DatagramPacket dp=null;
    47         try
    48         {
    49             while(true)
    50             {
    51                 //BufferedReader br=new BufferedReader(new InputStream(System.in));
    52                 byte[] buf=new byte[1024];
    53                 dp=new DatagramPacket(buf,buf.length);
    54                 ds.receive(dp);
    55                 String ip=dp.getAddress().getHostAddress();
    56                 int port =dp.getPort();
    57                 String data=new String(dp.getData(),0,dp.getLength());
    58                 System.out.println(ip+":"+port+"-"+data);
    59                 if(data.equals("886"))
    60                     System.out.println(ip+"退出聊天室!");//数据解析,如果是886就表明退出。
    61             }
    62             //ds.close();
    63         }
    64         catch (Exception e)
    65         {
    66             throw new RuntimeException();
    67         }
    68         
    69     }
    70 }
    71 class UDPDemo 
    72 {
    73     public static void main(String[] args) throws Exception
    74     {
    75         DatagramSocket dsSend=new DatagramSocket();
    76         DatagramSocket dsReceive=new DatagramSocket(10001);
    77 
    78         new Thread(new UDPReceive(dsReceive)).start();
    79         new Thread(new UDPSend(dsSend)).start();
    80 
    81 
    82 
    83     }
    84 }

    运行结果如下:

    4、TCP协议

       TCP传输

      两个端点的建立连接后会有一个传输数据的通道,这通道称为流,而且是建立在网络基础上的流,称之为socket流。该流中既有读取,也有写入。

      tcp的两个端点:一个是客户端,一个是服务端。

        客户端:对应的对象,Socket

        服务端:对应的对象,ServerSocket

      TCP客户端:

        ①:建立tcp的socket服务,最好明确具体的地址和端口。这个对象在创建时,就已经可以对指定ip和端口进行连接(三次握手)。

        ②:如果连接成功,就意味着通道建立了,socket流就已经产生了。只要获取到socket流中的读取流和写入流即可,只要通过getInputStream和getOutputStream就可以获取两个流对象。

        ③:关闭资源。

      TCP服务端:

        服务端需要明确它要处理的数据是从哪个端口进入的。

        当有客户端访问时,要明确是哪个客户端,可通过accept()获取已连接的客户端对象,并通过该对象与客户端通过IO流进行数据传输。

        当该客户端访问结束,关闭该客户端。

    接下来简单的演示一下客户端连接服务端的代码:

     1 import java.net.*;
     2 import java.io.*;
     3 class TCPdemoClient 
     4 {
     5     public static void main(String[] args) throws Exception
     6     {
     7         //创建socket服务
     8         Socket s=new Socket("192.168.1.103",10002);
     9         //获取输出流
    10         OutputStream out=s.getOutputStream();
    11         out.write("哥们来了!".getBytes());
    12         //关闭socket,也同时关闭了流。
    13         s.close();
    14     }
    15 }
    16 class TCPdemoServer
    17 {
    18     public static void main(String[] args) throws Exception
    19     {
    20         ServerSocket ss=new ServerSocket(10002);
    21         Socket s=ss.accept();//获取连接到服务器的socket对象
    22         String ip=s.getInetAddress().getHostAddress();
    23         System.out.println(ip+" connected!");
    24         InputStream in =s.getInputStream();
    25         byte[] buf =new byte[1024];
    26         int len=in.read(buf);//读取输入的数据
    27         String data=new String(buf,0,len);
    28         System.out.println(ip+" : "+data);
    29         s.close();//关流
    30         ss.close();
    31     }
    32 }

    结果如下:

      注意:TCP协议传输数据必须先开服务端,再开客户端。否则,客户端根本连接不上服务端。

    接下来写一个客户端和服务器端交互的例子,服务器端将客户端发送过来的数据转换成大写再发送回去,

     1 import java.net.*;
     2 import java.io.*;
     3 class TCPdemoClient 
     4 {
     5     public static void main(String[] args) throws Exception
     6     {
     7         //创建socket服务
     8         Socket s=new Socket("192.168.1.103",10003);
     9         //获取输出流,在tcp传输中注意结束标记和刷新流,所以用打印流很方便
    10         PrintWriter out=new PrintWriter(s.getOutputStream(),true);
    11         BufferedReader brInput=new BufferedReader(
    12             new InputStreamReader(s.getInputStream()));
    13         BufferedReader br=new BufferedReader(
    14             new InputStreamReader(System.in));
    15         for(String line=null;(line=br.readLine())!=null;)
    16         {
    17             out.println(line);
    18             if(line.equals("886"))
    19                 break;
    20             String result=brInput.readLine();
    21             System.out.println(result);
    22         }
    23         br.close();
    24         //关闭socket,也同时关闭了流。
    25         s.close();
    26     }
    27 }
    28 class TCPdemoServer
    29 {
    30     public static void main(String[] args) throws Exception
    31     {
    32         ServerSocket ss=new ServerSocket(10003);
    33         Socket s=ss.accept();//获取连接到服务器的socket对象
    34         String ip=s.getInetAddress().getHostAddress();
    35         System.out.println(ip+" connected!");
    36         BufferedReader br =new BufferedReader(
    37             new InputStreamReader(s.getInputStream()));
    38         //用打印流,自动刷新和换行,比较方便
    39         PrintWriter pw =new PrintWriter(s.getOutputStream(),true);
    40         for(String line=null;(line=br.readLine())!=null;)
    41         {
    42             System.out.println(ip+": "+line);
    43             pw.println(line.toUpperCase());
    44             if(line.equals("886"))
    45                 System.out.println(ip+"退出聊天!");
    46         }
    47         s.close();//关流
    48         ss.close();
    49     }
    50 }

    运行结果如下图

      1、上面练习中之所以客户端结束后,服务端也随之结束的原因在于:客户端的socket关闭后,服务端获取的客户端socket读取流也关闭了,因此读取不到数据,line = bufIn.readLine()为null,循环结束,ServerSocket的close方法也就执行关闭了。

      2、上面练习中的客户端和服务端的PrintWriter对象out获取到数据后,一定要刷新,否则对方(服务端或客户端)就获取不到数据,程序便无法正常执行。刷新操作可以通过PrintWriter类的println()方法实现,也可以通过PrintWriter类的flush()方法实现。但是,由于获取数据的方法是BufferedReader对象bufIn的readLine()方法(阻塞式方法),此方法只有遇到“ ”标记时,才认为数据读取完毕,赋值给String对象line。所以,使用PrintWriter类的flush()方法刷新数据时一定要记得追加“ ”,标志行结束。

      注意,在客户端向服务器端上传文件的时候,在上传文件完成的时候,客户端要给服务器一个信号文件传输完毕,否则只要流没有断开,服务器一直在阻塞在读流数据的函数中,这个结束标记可以是自定义的结束符(如:over),时间戳标记,最好的方法是s.shutdownOutput();调用socket方法关闭output流通知服务器传输完成。

      现实中服务器都是通过多线程来响应不同的客户端的请求的,接下来就模拟一个客户端图片上传服务器多线程方法:

     1 import java.io.*;
     2 import java.net.*;
     3 class UploadThread implements Runnable
     4 {
     5     private Socket s;
     6     UploadThread(Socket s)
     7     {
     8         this.s=s;
     9     }
    10     public void run()
    11     {
    12         int count=0;
    13         String ip=s.getInetAddress().getHostAddress();
    14         System.out.println(ip+"connected!");
    15         try
    16         {
    17             File f=new File(ip+".jpg");
    18             //如果文件已经存在
    19             while(f.exists())
    20             {
    21                 f=new File(ip+"("+(++count)+").jpg");
    22             }
    23             InputStream is=s.getInputStream();
    24             FileOutputStream fos=new FileOutputStream(f);
    25             byte[] buf=new byte[1024];
    26             for(int len=0;(len=is.read(buf))!=-1;)
    27             {
    28                 fos.write(buf,0,len);
    29             }
    30             OutputStream out=s.getOutputStream();
    31             out.write("上传成功".getBytes());
    32             fos.close();
    33             s.close();
    34         }
    35         catch (Exception e)
    36         {
    37             throw new RuntimeException();
    38         }
    39     }
    40 }
    41 class PicUploadServer
    42 {
    43     public static void main(String[] args) throws Exception
    44     {
    45         ServerSocket ss=new ServerSocket(10004);
    46         while(true)
    47         {
    48             Socket s=ss.accept();
    49             new Thread(new UploadThread(s)).start();
    50         }
    51     }
    52 }
    53 class UploadClient
    54 {
    55     public static void main(String[] args) throws Exception
    56     {
    57         Socket s=new Socket("192.168.1.103",10004);
    58         FileInputStream fis=new FileInputStream("d:\1.jpg");
    59         //获取输出流,给服务器发送字节数据
    60         OutputStream os=s.getOutputStream();
    61         byte[] buf=new byte[1024];
    62         for(int len;(len=fis.read(buf))!=-1;)
    63         {
    64             os.write(buf,0,len);
    65         }
    66         //告诉服务器数据发送完毕
    67         s.shutdownOutput();
    68         //接收服务器的返回
    69         InputStream is=s.getInputStream();
    70         byte[] bufIn=new byte[1024];
    71         int len = is.read(bufIn);        
    72         System.out.println(new String(bufIn,0,len));
    73         fis.close();
    74         s.close();
    75     }
    76 }

    图片上传成功了!

     

      Socket类的构造函数中,有一个空参数的构造函数:

            Socket()//通过系统默认类型的 SocketImpl创建未连接套接字对象

           可以通过connect(SocketAddress endpoint)方法来连接服务器。而SocketAddress是一个抽象类,它的子类InetSocketAddress实现了IP套接字地址(IP地址+端口号)。所以就可以连接到服务器了。

    5、URL和URLConnection

      URL:统一资源定位符,也就是说根据URL能够定位到网络上的某个资源,它是指向互联网“资源”的指针。 

      方法:

            1)构造函数:URL(String protocol,String host,int port,String file);//根据指定 protocol、host、port号和 file 创建 URL对象。

            2)String getProtocol();//获取协议名称

            3)String getHost();//获取主机名

            4)int getPort();//获取端口号

            5)String getFile();//获取URL文件名

            6)String getPath();//获取此URL的路径部分

            7)String getQuery();//获取此URL的查询部,客户端传输的特定信息 

      URLConnection方法:

            1)URLConnection openConnection();//用URL调用此方法,返回一个 URLConnection 对象,它表示到 URL 所引用的远程对象的连接。

            2)InputStream getInputStream();//获取输入流

            3)OutputStream getOutputStream();//获取输出流

     

     1 import java.net.*;
     2 import java.io.*;
     3 class URLDemo 
     4 {
     5     public static void main(String[] args)throws Exception 
     6     {
     7         String strURL="http://192.168.1.100:8080/myweb/hello.html?name=admin";
     8         URL u=new URL(strURL);
     9         System.out.println("getProtocol: "+u.getProtocol());
    10         System.out.println("getHost: "+u.getHost());
    11         System.out.println("getPort: "+u.getPort());
    12         System.out.println("getFile: "+u.getFile());
    13         System.out.println("getPath: "+u.getPath());
    14         System.out.println("getQuery: "+u.getQuery());
    15         URLConnection uc=u.openConnection();
    16         InputStream is=uc.getInputStream();//等价于InputStream is=u.openStream();
    17         byte[] buf=new byte[1024];
    18         int len=is.read(buf);
    19         System.out.println(new String(buf,0,len));
    20         is.close();
    21     }
    22 }

    输出结果为:

      通过URL获取的流,接收到服务器的响应信息,URLConnection对象已经把响应头给解析了,只取到了消息体的数据,如果需要消息头的信息,URLConnection.getHeaderField(“具体的属性名”);来获取。

      网络编程内容总结到这里就结束了,对于网络编程而言,重要的是理解其步骤,按照步骤的需要,一步步搭建根基! 客户端和服务端需要交互,那么就要构建相对应的流,供其输入和输出! 对于阻塞式方法,一定要注意,提供停止标签! 对于PrintWriter ,记得用println而不是write;不要忘了加上true,自动刷新!

  • 相关阅读:
    web攻击
    HTTP与HTTPS
    HTTP确认访问用户身份的认证
    Http协议(三)返回结果的HTTP状态码
    HTTP协议四(http首部)
    HTTP协议(二)报文信息
    HTTP协议(一)
    Windows10 如何设置软件开机自起动和关闭
    获取Chrome版本并下载匹配的chromedriver
    多线程Runnable
  • 原文地址:https://www.cnblogs.com/dengzhenyu/p/4842668.html
Copyright © 2020-2023  润新知