【黑马程序员】网络编程知识总结_public static void main(string[] args) throws exce-CSDN博客

本文链接：https://blog.csdn.net/xftdfuao/article/details/37653937

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ --------------------

网络编程

1、网络编程-概述

1. 网络通讯要素：

IP地址：InetAddress网络中设备的标识，不易记忆，可用主机名。

本机主机地址：127.0.0.1 主机名：localhost

代码演示：

import java.net.*;

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());

//System.out.println("name:"+i.getHostName());

InetAddress ia =InetAddress.getByName("192.168.1.254");

System.out.println("address:"+ia.getHostAddress());

System.out.println("name:"+ia.getHostName());

}

小结：如果在选取的ip地址中搜索不到相对应的主机名，则系统会返回对应的ip地址

2. 端口号

用于标识进程的逻辑地址，不同进行的标识，有效端口：0~65535，其中0~1024都被系统使用或保留端口

传输协议：通讯规则的常见协议：TCP、UDP

2、网络编程(TCP和UDP)

TCP特点：

1) 建立连接，形成传输数据的通道；

2) 在连接中进行大量数据传输；

3) 通过三次“握手”完成连接，是可靠协议

4) 必须建立连接，效率会稍低。

UDP特点：

1) 将数据及源和目的封装到数据中，不需要建立连接；

2) 每个数据包的大小都限制在64k内；

3) 因为连接，是不可靠协议；‘

4) 不需要建立连接，速度快

3、网络编程(Socket)

1. Socket特点：

1) Socket就是为网络服务提供的一种机制；

2) 通信的两端都有Socket；

3) 网络通信其实就是Socket间的通信；

4) 数据在两个Socket间通过IO传输。

2. UDP传输

1) DatagramSocket与DatagramPacket

2) 建立发送端，接收端；

3) 建立数据包；

4) 调用Socket的发送接收方法；

5) 关闭Socket

其中，发送端与接收端是两个独立运行的程序

public class DatagramSocket extends Object ：此类表示用来发送和接收数据报包的套接字，

public final class DatagramPacket extends Object: 此类表示数据报包。数据报包用来实现无连接包投递服务。具备发送和接收功能，在进行UDP传输时，需要明确一个是发送端，一个是接收端。

DatagramPacket(byte[] buf,int length, InetAddress address , int port)构造数据报包，用来将长度为length的包发送到指定主机上的指定端口号上。

UDP的发送端：

1) 建立UDP的socket服务，创建对象时如果没有明确端口，系统会自动分配一个未被使用的端口；

2) 明确要发送的具体数据；

3) 将数据封装成了数据包；

4) 用socket服务的send方法将数据包发送出去；

5) 关闭资源

代码演示：

[java]view plaincopy 
    
 import java.net.*;  
 class  UdpSend{  
        publicstatic void main(String[] args) {  
               //1.建立udp的socket服务  
               DatagramSocket ds = new DatagramSocket(8888);//指定发送端口，不指定系统会随机分配  
               //2.明确要发送的具体数据  
               String text = "udp传输演示，哥们来了";  
               byte[]buf = text.getBytes();  
               //3.将数据封装成了数据包  
               DatagramPacke tdp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1."),10000);  
               //4.用socket服务的send方法将数据包发送出去  
               ds.send(dp);  
               //5.关闭资源  
               ds.close();  
        }  
 }  

UDP的接收端：

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

2) 定义数据包，用于储存接收到的数据；

3) 通过socket服务的接收方法将受到的数据存储到数据包中。

4) 通过数据包的方法获取数据包中的具体数据内容，如ip、端口和数据

5) 关闭资源。

代码演示：

[java]view plaincopy 
    
 import java.net.*;  
 class UdpRece {  
        public static void main(String[] args) {  
               //1.创建udp的socket服务  
               DatagramSocket ds = new DatagramSocket(10000);  
               //2.定义数据包，用于存储接收到的数据。先定义字节数组，数据包会把数据存储到字节数组中  
               byte[]buf = new byte[1024];  
               DatagramPacket dp = new DatagramPacket(buf,buf.length);  
               //3.通过socket服务的接收方法将收到的数据存储到数据包中  
               ds.receive(dp);//该方法是阻塞式方法  
               //4.通过数据包的方法获取数据包中的具体数据内容，比如ip，端口和数据  
               String ip = dp.getAddress().getHostAddress();  
               int port = dp.getPort();  
               String text = new String(dp.getData(),0,dp.getLength());//将字节数组中的有效部分转成字符串  
               System.out.println(ip+ ":" + port + "---" + text);  
               //5.关闭资源  
               ds.close();  
        }  
 }  

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

TCP的两个端点：一个是客户端，一个是服务端。

客户端：对应对象是Socket

服务端：对应对象是ServerSocket

TCP的客户端

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

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

3) 关闭资源。

代码演示：

[java]view plaincopy 
    
  import java.io.*;  
 import java.net.*;  
 class TcpClient {  
 public static void main(String[] args) {  
         Socket s = new Socket("127.0.0.1",10001);  
         OutputStream out = s.getOutputStream();//获取了socket流中的输出流对象。  
         out.write("tcp演示，哥们又来了".getBytes());  
         s.close();  
 <span style="white-space:pre">  </span>}  
 }  

TCP的服务端：

1) 创建服务端socket服务，并监听一个端口；

2) 服务端为了给客户端提供服务，获取客户端的内容，可以通过accept方法获取连接过来的客户端对象。

3) 可以通过获取到的socket对象的socket流和具体的客户端进行通讯

4) 如果通讯结束，关闭资源。注意：要先关闭客户端，再关客户端

代码演示：

[java]view plaincopy 
    
 import java.io.*;  
 import java.net.*;  
 class TcpServer {  
       public static void main(String[] args) {  
              ServerSocket ss = new ServerSocket(10001);//建立服务端的socket服务  
              Socket s = ss.accept();//获取客户端对象  
              String ip = s.getInetAddress().getHostAddress();  
              System.out.println(ip+ "....contected");  
              //可以通过获取到的socket对象中的socket流和具体的客户端进行通讯  
              InputStream in = s.getInputStream();//读取客户端的数据，使用客户端对象的socket读取流  
              byte[]buf = new byte[1024];  
              int len = in.read(buf);  
              String text = new String(buf,0,len);  
              System.out.println(text);  
              //如果通讯结束，关闭资源。注意：要先关闭客户端，再关闭服务端  
       }  
 }  

练习：TCP复制文件

代码演示：

[java]view plaincopy 
    
 import java.io.*;  
 import java.net.*;  
 class TextClient{  
        public static void main(String[] args) throws Exception{  
               Socket s = new Socket("127.0.0.1",10006);  
         
               BufferedReader bufr =  
                      new BufferedReader(new FileReader("IPDemo.java"));  
    
               PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
    
               Stringline = null;  
    
               while((line=bufr.readLine())!=null){  
                      out.println(line);  
               }  
               //out.println("over");//定义结束标记  
               s.shutdownOutput();//关闭客户端的输出流，相当于给流中加入一个结束标记-1。  
               BufferedReader bufIn =  
                      new BufferedReader(new InputStreamReader(s.getInputStream()));  
    
               String str = bufIn.readLine();  
               System.out.println(str);  
    
               bufr.close();  
               s.close();  
        }  
 }  

[java]view plaincopy 
    
 class TextServer{  
        public static void main(String[] args)throws Exception{  
               ServerSocket ss = new ServerSocket(10006);  
               Sockets = ss.accept();  
    
               String ip = s.getInetAddress().getHostAddress();  
               System.out.println(ip+"......connected");  
               BufferedReader bufIn =  
                      new BufferedReader(new InputStreamReader(s.getInputStream()));  
    
               PrintWriter out = new PrintWriter(new FileWriter("server.txt"),true);  
    
               String line = null;  
               while((line=bufIn.readLine())!=null){  
                      //if("over".equals(line))  
                      //    break;  
                      out.println(line);  
               }  
               PrintWriter pw = new PrintWriter(s.getOutputStream(),true);  
               pw.println("上传成功");  
               out.close();  
               s.close();  
               ss.close();  
        }  
 }  

小结：由于运用到了readLine方法，因此就会有相应的阻塞式方法，于是就要加入相应结束标记，查看Socket的API文档发现，当文件写到末尾时，加入shutdownOutput()方法，即可让其添加了一个类似于-1的结束标记。

4. 网络编程(URL -URLConnection)

构造方法：

String getFile():获取此URL的文件名

String getHost():获取此URL的主机名(如果适用)

String getPath():获取此URL的路径部分

int getPort():获取此URL的端口号

String getProtocol():获取此URL的协议名称

String getQuery()：获取此URL的查询部分

URLConnection openContection(): 返回一个URLConnection对象，它表示到URL所引用的远程对象的连接；

public ServerSocket(int port, intbacklog)：

port:指定的端口；

backlog:队列的最大程度，也就是支持最多用户

代码演示：

[java]view plaincopy 
    
 import java.io.*;  
 import java.net.*;  
 class URLConnectionDemo {  
        public static void main(String[] args) throws Exception{  
               URL url = new URL("http://127.0.0.1:8080/myweb/demo.html");  
    
               URLConnection conn = url.openConnection();  
               System.out.println(conn);  
    
               InputStream in = conn.getInputStream();  
               byte[] buf = new byte[1024];  
               int len = in.read(buf);  
               System.out.println(new String(buf,0,len));  
        }  
 }  

十、正则表达式

1、正则表达式特点：符合一定规则的表达式。

作用：专门用于操作字符串

特点：用于一些特定的符号来表示一些代码操作，这样就简化了书写；

好处：可以简化对字符串的复杂操作；

弊端：符号的出现虽然简化了书写，但是却降低了阅读性。

组：用小括号表示，没定义一个小括号，就是一个组，而且有自动编号，从1开始。只要使用组，对应的数字就是使用该组的内容。其中数组要加\\,而(aaa(bbb(ccc))(eee))分辨组的技巧：从左括号开始数即可。有几个左括号就是几组。

2、常见操作：

1) 匹配：其实用的就是String类中的matches方法

String reg = “[1-9][0-9]{4,14}”;

boolean b = qq.matches(reg);//将正则和字符串关联对字符串进行匹配

2) 切割：其实用的就是String类中的split方法。

3) 替换：其实用的就是String类中的replaceAll()方法；

4) 获取：

(1) 先要将正则表达式编译成正则对象，使用的是Pattern中静态方法：compile(regex);

(2) 通过Pattern对象获取Matcher对象。

Pattern用于描述正则表达式，可以对正则表达式进行解析。而将规则操作字符串，需要从新封装到匹配器对象Matcher中。然后使用Matcher对象的方法来操作字符串。

如何获取匹配器对象呢？

通过Pattern对象中的matcher方法。该方法可以让正则跪着和字符串相关联，并返回匹配器对象。

(3) 使用Matcher对象中的方法即可对字符串进行各种正则操作。

代码演示：

[java]view plaincopy 
    
  importjava.util.regex.*;  
 class  RegexDemo2{  
          public static void main(String[] args) {  
                    getDemo();  
          }  
          public static void getDemo(){  
                    String str ="ming tian jiu yao fang jia le,da jia.";  
                    //str ="123456";  
                    //String reg= "[1-9]\\d{4,14}";  
                    String reg ="\\b[a-z]{4}\\b";// \b表示单词边界  
    
                    //将规则封装成对象  
                    Pattern p =Pattern.compile(reg);  
    
                    //让正则对象和要作用的字符串相连接，获取匹配器对象。  
                    Matcher m =p.matcher(str);  
    
                    //System.out.println(m.matches());//其实String类中的matches方法，用的就是Pattern和Matcher对象来完成的。  
                                                                                              //只不多被String的方法封装后，用起来较为简单，但是功能却单一。  
                     
                    //boolean b= m.find();//将规则作用到字符串上，并进行符合规则的字串查找  
                    //System.out.println(b);  
 //               System.out.println(m.group());//用于获取匹配后的结果  
    
                    while(m.find()){  
                             System.out.println(m.group());  
                             System.out.println(m.start()+"..."+m.end());  
                    }  
          }  
 }  

注意：在进行查找获取前，不能在其前面再添加匹配，否则获取到的数据会出现错误，例如matches()会提前匹配，然后其索引位就会一次往后推移

练习：网页爬虫(蜘蛛)

[java]view plaincopy 
    
 import java.io.*;  
 import java.util.regex.*;  
 import java.net.*;  
 class RegexTest2{  
        public static void main(String[] args) throws Exception{  
               //getMails();  
               getMails_1();  
        }  
    
 //通过网页获取邮件地址  
        public static void getMails_1()throws Exception{  
               URL url = new URL("http://127.0.0.1:8080/myweb/mail.html");  
               URLConnection conn = url.openConnection();  
    
               BufferedReader bufIn =  
                      new BufferedReader(new InputStreamReader(conn.getInputStream()));  
    
               String line = null;  
               String mailreg ="\\w+@\\w+(\\.\\w+)+";  
               Pattern p = Pattern.compile(mailreg);  
    
               while((line=bufIn.readLine())!=null){  
                      Matcher m = p.matcher(line);  
                      while(m.find()){  
                             System.out.println(m.group());  
                      }  
               }  
        }  
 //通过本地文件获取邮件地址  
        public static void getMails()throws Exception{  
               BufferedReader bufr =  
                      new BufferedReader(new FileReader("mail.txt"));  
    
               String line = null;  
    
               String mailreg = "\\w+@\\w+(\\.\\w+)+";  
               Pattern p = Pattern.compile(mailreg);  
    
               while((line=bufr.readLine())!=null){  
                      Matcher m = p.matcher(line);  
                      while(m.find()){  
                             System.out.println(m.group());  
                      }  
               }  
        }  
 }  