黑马程序员——网络编程_移动应用软件开发 黑马程序员 网络编程-程序员宅基地

------- android培训、java培训、期待与您交流！ ----------

第一讲     概述 

1、网络模型：OSI参考模型和TCP/IP参考模型

图示：

        一般来说开发处于传输层和网际层，应用层为：FTP和HTTP协议等，传输层为：UDP和TCP等，网际层为：IP。

        通常用户操作的是应用层，而编程人员需要做的是传输层和网际层，用户在应用层操作的数据，经过逐层封包，最后到物理层发送到另一个模型中，再进行逐层解包，图示为：

 

2、网络通信三要素：IP地址，端口号，传输协议

A、IP地址

        a、它是网络中的设备标识

        b、不易记忆，可用主机名表示，两者存在映射关系

        c、本机回环地址：127.0.0.1，主机名为：localhost。

IP地址：java中对应的是InetAddress类，存在于java.net包中。

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地址主机名。

     （三）如何获取任意一台主机的IP地址对象：

                1）功能：返回InetAddress对象

                2）对于任意主机，需要指定传入主机名的参数

注意：如果IP地址和对应的主机名，这种映射关系没有在网络上，就不会解析成功，返回的还是指定的IP。


B、端口号：

        a、用于标识进程的逻辑地址，不用进程的标识。

        b、有效端口：0 ~65535，系统使用或保留的端口是：0~ 1024。


C、传输协议：

        即通信规则，包含TCP和UDP协议

UDP协议：

        是面向无连接，明确了对方的端口，无论在不在网上，只管传输，不在就会丢失数据。只求速度，应用于网络视频会议和聊天等应用程序中。

协议特点：

         a、面向无连接，即将数据及源和目的封装成数据包中，不建立链接的发送

         b、每个数据包的大小限制在64K之内

         c、因无连接，是不可靠的协议

         d、不建立连接，速度快。

TCP协议：

        是面向连接的，必须连接成功才能传输数据，应用于下载等程序上

协议特点：

         a、面向连接，在建立连接后，形成传输数据的通道

         b、在连接中进行大数据量的传输

         c、通过三次握手完成连接，是可靠的协议

         d、必须建立连接，效率稍慢

三次握手：第一次本方发送请求，第二次对方确认连接，第三次本方再次确认连接成功。


3、通信的步骤：

        1）找到IP地址

        2）数据要发送到对象指定应用程序，为标识这些应用程序，所以给这些网络应用程序都用数字标识，为方便称呼这个数字，叫做端口，即逻辑端口。

        3）定义通信规则，称之为协议。国际组织定义了通用协议，即TCP/IP。

注意：必须要有数字标识才能将数据发送到应用程序上。

 

第二讲     传输协议

一、Socket

        1、它被称之为插座，相当于港口一样，是网络服务提供的一种机制。

        2、通信两端都要有Socket，才能建立服务。

        3、网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。

 

二、UDP传输

1、通过类DatagramSocket，此类表示用发送和接收数据包的套接字，即Socket。

2、方法：

        1）创建 UDPSocket发送服务对象：

              DatagramSocket()，不指定端口。DatagramSocket(int port)，指定端口。

        2）发送：void send(DatagramPacket p)

        3）接收：void receive(DatagramPacket p)

       其中DatagramPacket：数据报包用来实现无连接包投递服务的，每条报文仅根据该包中包含的信息从一台机器路由到另一台机器中。凡是带地址（InetAddress）的都是用于发送包的。

3、步骤

        1）发送数据：

              a、建立UDPSocket服务，在此无需指定端口，也可以将端口加入。如果不指定的话，系统会随机分配一个端口，如第一次运行时端口为1093，那么第二次就会顺延为1094，再运行会一直顺延，因为之前的端口还没有得到释放，所以会顺延端口号值。

              b、提供数据，并将数据封装到数据包中

              c、通过socket服务的发送功能，将数据包发送出去

              d、关闭资源

        2）接收数据：

              a、定义UDPSocket服务。通常会监听一个端口，其实就是给这个接收网路应用程序定义数字标识，方便于明确哪些数据过来该应用程序可以处理。

              b、定义一个数据包，用来存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。

              c、通过socket服务的receive方法接收到的数据存入已定义好的数据包中

              d、通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上

              e、关闭资源

        在定义接收数据的方法中，仍会在DatagramSocket构造函数中传入DatagramPacket的参数，这是因为收到的数据太多，需要解析，通过将数据封装成对象，易于解析，所以需要传入参数。

注意：

        1、发送端与接收端是两个独立的运行程序。

        2、在发送端，要在数据包对象中明确目的地IP及端口。

        3、在接收端，要指定监听的端口。

练习

[java]  view plain copy
  1. /* 
  2. 用键盘录入的方式，来发送数据 
  3. */  
  4.   
  5. import java.net.*;  
  6. import java.io.*;  
  7. //UDP 发送端  
  8. class UdpSend    
  9. {  
  10.     public static void main(String[] args)throws Exception  
  11.     {  
  12.         //1、创建udp Socket服务  
  13.         DatagramSocket ds=new DatagramSocket(9999);  
  14.         //2、确定数据，从键盘录入，并把键盘录入的数据封装成数据包  
  15.         DatagramPacket dp=null;  
  16.         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  
  17.         String line=null;  
  18.         while((line=br.readLine())!=null)  
  19.         {  
  20.             byte[] buf=line.getBytes();  
  21.             dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10000);  
  22.             //3、通过Socket服务，将已有的数据包发送出去  
  23.             ds.send(dp);  
  24.             if ("886".equals(line))  
  25.             {  
  26.                 break;  
  27.             }  
  28.         }  
  29.         //4、关闭资源  
  30.         ds.close();  
  31.           
  32.     }  
  33. }  
  34.   
  35. //UDP 接收端  
  36. class UdpReceive  
  37. {  
  38.     public static void main(String[] args)throws Exception  
  39.     {  
  40.         //1、创建udp Socket服务  
  41.         DatagramSocket ds=new DatagramSocket(10000);  
  42.         //一直处于接收状态  
  43.         while (true)  
  44.         {  
  45.             //2、定义数据包，用于存储数据  
  46.             byte[] buf=new byte[1024];  
  47.             DatagramPacket dp=new DatagramPacket(buf,buf.length);  
  48.             //3、通过Socket服务，将数据接收并存储进数据包中  
  49.             ds.receive(dp);  
  50.             //4、通过数据包的方法获取其中的数据  
  51.             String ip=dp.getAddress().getHostAddress();  
  52.             String data=new String(dp.getData(),0,dp.getLength());  
  53.             int port=dp.getPort();  
  54.   
  55.             System.out.println("IP:"+ip+"=="+data);  
  56.         }  
  57.         //5、关闭资源  
  58.         //ds.close();  
  59.     }  
  60. }     


三、TCP传输

1、TCP分客户端和服务端。客户端对应的对象是Socket，服务端对应的对象是ServerSocket。

2、方法：

        1）创建客户端对象：

              Socket()：创建空参数的客户端对象，一般用于服务端接收数据

              Socket(String host,int port)，指定要接收的IP地址和端口号

        2）创建服务端对象：ServerSocket(int port)：指定接收的客户端的端口

        3）Socket accept()：监听并接受到此套接字的连接

        4）void shutdownInput()：此套接字的输入流至于“流的末尾”

        5）void shutdownOutput()：禁用此套接字的输出流

        6）InputStream getInputStream()：返回此套接字的输入流，Socket对象调用

        7）OutputStream getOutputStream()：返回套接字的输出流，Socket对象调用

3、基本思路

客户端：

        1）客户端需要明确服务器的ip地址以及端口，这样才可以去试着建立连接，如果连接失败，会出现异常。

        2）连接成功，说明客户端与服务端建立了通道，那么通过IO流就可以进行数据的传输，而Socket对象已经提供了输入流和输出流对象，通过getInputStream(),getOutputStream()获取即可。

        3）与服务端通讯结束后，关闭Socket。

服务端：

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

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

        3）当该客户端访问结束，关闭该客户端。

4、步骤

客户端：

        通过查阅Socket对象的API文档，发现在该对象在建立时，就可去连接指定主机，因为TCP是面向连接的，所以在建立Socket服务时，就要有服务端存在，并连接成功，形成通路后，再通过该通道进行数据的传输。

         1）创建Socket服务，并指定要连接的主机端口。通路一建立，就会产生Socket流（包括输入流和输出流），通过方法获取

         2）为了发送数据，应获取Socket中的输出流，如果要接收服务端的反馈信息，还需要获取Socket的输入流

         3）通过输出流的write()方法将要发送的数据写入到流中

         4）关闭Socket流资源

服务端：

        服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。需监听一个端口。

         1）建立服务端的Socket服务，并监听一个端口。通过ServerSocet带端口参数的构造函数

         2）获取连接过来的客户对象，通过ServerSocket的accept()方法，此方法是阻塞式的，如果服务端没有连接到就会一直等待

         3）客户端如果发过来数据，则服务端要使用对应的客户端对象，并获取到该客户端对象的读取流读取发过来的数据，并输出到指定目的地。

         4）关闭服务端（可选）。一般服务端是常开的，因为在实际应用中，随时有客户端在请求连接和服务。但这里需要定时关闭客户端对象流，避免某一个客户端长时间占用服务器端。

练习

[java]  view plain copy
  1. /* 
  2. 练习 
  3. 需求：建立一个文本转换服务器 
  4. 客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端。 
  5. 而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束。 
  6.  
  7. 分析： 
  8. 客户端： 
  9. 既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。 
  10. 源：键盘录入 
  11. 目的：网络设备，网络输出流。 
  12. 而且操作的是文本数据。可以选择字符流。 
  13.  
  14. 步骤： 
  15. 1、建立服务 
  16. 2、获取键盘录入 
  17. 3、将数据发给服务端 
  18. 4、获取服务端返回的大写数据 
  19. 5、结束，管资源。 
  20.  
  21. 都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。 
  22.  
  23.  
  24. 此练习出现的问题： 
  25. 现象：客户端和服务端都在莫名的等待。 
  26. 原因：因为客户端和服务端都有阻塞式方法。这些方法没有读到结束标记。那么就一直等。而导致两端都在等待。 
  27. 解决：需要用到刷新和换行的方式将写入和读取的数据从流中刷新到内存中 
  28.     方式一：可用高效缓冲区类的newLine()换行作为结束标记，并用flush()进行刷新。 
  29. 方式二：可用PrintWriter(s.getOutputStrean(),true)创建输出流对象，true作用是刷新，通过打印方法println()换行，“ln”表示换行。 
  30.  
  31. */  
  32.   
  33. import java.io.*;  
  34. import java.net.*;  
  35. class  TcpClient  
  36. {  
  37.     public static void main(String[] args) throws Exception  
  38.     {  
  39.         //创建Socket服务  
  40.         Socket s=new Socket("127.0.0.1",10000);  
  41.           
  42.         //定义读取键盘数据的流对象  
  43.         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  
  44.           
  45.         //定义目的，将数据写入到Socket输出流。发给服务端  
  46.         //BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
  47.         PrintWriter pw=new PrintWriter(s.getOutputStream(),true);  
  48.           
  49.         //定义一个Socket读取流，读取服务端返回的大写信息。  
  50.         BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));  
  51.   
  52.         String line=null;  
  53.         while ((line=br.readLine())!=null)  
  54.         {  
  55.               
  56.             if("over".equals(line))  
  57.                 break;  
  58.   
  59.             //bwout.write(line);//写入输出流  
  60.             //bwout.newLine();//换行  
  61.             //bwout.flush();//刷新  
  62.             pw.println(line);//将数据写入流中  
  63.   
  64.             String data=brin.readLine();//读取返回的信息  
  65.             System.out.println(data);  
  66.   
  67.         }  
  68.         br.close();//关流  
  69.         s.close();  
  70.     }  
  71. }  
  72. /* 
  73. 服务端： 
  74. 源：Socket读取流 
  75. 目的：Socket输出流 
  76. 都是文本，装饰 
  77. */  
  78.   
  79. class TcpServer  
  80. {  
  81.     public static void main(String[] args)throws Exception  
  82.     {  
  83.         //创建服务端的ServerSocket服务,并指定监听端口  
  84.         ServerSocket ss =new ServerSocket(10000);  
  85.           
  86.         //获取客户端连接  
  87.         Socket s=ss.accept();  
  88.   
  89.         //获取客户端ip  
  90.         System.out.println(s.getInetAddress().getHostName()+" connected.......");  
  91.   
  92.         //读取Socket读取流中的数据  
  93.         BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));  
  94.   
  95.         //将大写数据写入到Socket输出流，并发送给客户端。  
  96.         //BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
  97.         PrintWriter pw=new PrintWriter(s.getOutputStream(),true);  
  98.   
  99.         String line=null;  
  100.         while ((line=brin.readLine())!=null)  
  101.         {  
  102.             System.out.println(line);  
  103.   
  104.             //bwout.write(line.toUpperCase());//将读到数据转换为大写后返回  
  105.             //bwout.newLine();//换行  
  106.             //bwout.flush();//刷新  
  107.   
  108.             pw.println(line.toUpperCase());//将读到数据转换为大写后返回  
  109.         }  
  110.         s.close();//关流  
  111.         ss.close();关闭资源（可选）  
  112.     }  
  113. }  

第三讲     应用

一、用TCP客户端并发上传图片

1、一对一（单线程）上传的思路：

客户端

        a、服务端点。

        b、读取客户端已有的图片数据

        c、通过Socket输出流将数据发给服务端

        d、读取服务端反馈信息。

        e、关闭

服务端

        a、服务端服务，并监听窗口

        b、获取客户端对象，并获取客户ip

        c、读取客户端输入流数据

        d、写入文件

        e、用客户端输出流反馈信息

        f、关流

2、单线程的服务端有个局限性。当A客户端连接上以后，被服务端获取到。服务端执行具体流程。这时B客户端连接，只能等待。因为服务端还没有处理完A客户端的请求。还没有循环回来执行下一次accept方法。所以，暂时获取不到B客户端对象。

        那么为了可以让多个客户端同时并发访问服务端。服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。

如何定义线程呢？

        只要明确了每一个客户端要在服务端执行的代码，将该代码存入run方法即可。

代码：

[java]  view plain copy
  1. /* 
  2. 需求：并发上传图片 
  3. */  
  4.   
  5. import java.io.*;  
  6. import java.net.*;  
  7. //客户端  
  8. class  PicClient  
  9. {  
  10.     public static void main(String[] args) throws Exception  
  11.     {  
  12.         //对传入的值进行判断  
  13.         if (args.length!=1)  
  14.         {  
  15.             System.out.println("请指定一个图片文件！");  
  16.             return;  
  17.         }  
  18.   
  19.         File file=new File(args[0]);  
  20.   
  21.         //对文件路径进行判断  
  22.         if (!(file.exists()&&file.isFile()))  
  23.         {  
  24.             System.out.println("你上传的文件有问题，非文件或者不存在！");  
  25.             return;  
  26.         }  
  27.   
  28.         //判断是否是图片文件  
  29.         if (!file.getName().endsWith(".jpg"))  
  30.         {  
  31.             System.out.println("图片格式错误，请重新选择！");  
  32.             return;  
  33.         }  
  34.   
  35.         //对文件大小进行判断  
  36.         if (file.length()>1024*1024*5)  
  37.         {  
  38.             System.out.println("你上传的文件过大,居心叵测！");  
  39.             return;  
  40.         }  
  41.   
  42.         //创建服务  
  43.         Socket s=new Socket("localhost",10000);  
  44.         //读取图片数据  
  45.         FileInputStream fis=new FileInputStream(file);  
  46.           
  47.         //用Socket服务输出流写入数据  
  48.         OutputStream out =s.getOutputStream();  
  49.   
  50.         BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));  
  51.   
  52.         byte[] buf=new byte[1024];  
  53.   
  54.         int len=0;  
  55.   
  56.         while ((len=fis.read(buf))!=-1)  
  57.         {  
  58.             out.write(buf,0,len);  
  59.         }  
  60.   
  61.         //结束标记，表示文件数据已经上传完了  
  62.         s.shutdownOutput();  
  63.   
  64.         String info=in.readLine();//读取返回信息  
  65.         System.out.println(info);  
  66.   
  67.         fis.close();//关流  
  68.         s.close();  
  69.   
  70.     }  
  71. }  
  72.   
  73. //服务端  
  74. class PicServer  
  75. {  
  76.     public static void main(String[] args)throws Exception  
  77.     {  
  78.         //创建服务，监听端口  
  79.         ServerSocket ss=new ServerSocket(10000);  
  80.           
  81.         while (true)  
  82.         {  
  83.             //获取客户端对象  
  84.             Socket s=ss.accept();  
  85.             //客户端执行线程  
  86.             new Thread(new PicThread(s)).start();  
  87.         }  
  88.           
  89.         //ss.close();  
  90.     }  
  91. }  
  92.   
  93. //利用多线程实现并发上传  
  94. class PicThread implements Runnable  
  95. {  
  96.     private Socket s;  
  97.     PicThread(Socket s)  
  98.     {  
  99.         this.s=s;  
  100.     }  
  101.     public void run()  
  102.     {  
  103.         int count=1;  
  104.         //获取客户端ip  
  105.         String ip=s.getInetAddress().getHostAddress();  
  106.         try  
  107.         {         
  108.             System.out.println(ip+"  connected.....");  
  109.   
  110.             //通过客户端的读取流读取数据  
  111.             InputStream in=s.getInputStream();  
  112.             //文件保存路径  
  113.             File dir =new File("C:\\Users\\asus\\Desktop");  
  114.             //文件名  
  115.             File file=new File(dir,ip+".jpg");  
  116.             //判断文件是否存在  
  117.             while(file.exists())  
  118.             {  
  119.                 file=new File(dir,ip+"("+(count++)+").jpg");  
  120.             }  
  121.   
  122.             //将数据写入到指定文件中  
  123.             FileOutputStream fos=new FileOutputStream(file);  
  124.   
  125.             byte[] buf=new byte[1024];  
  126.             int len=0;  
  127.             while ((len=in.read(buf))!=-1)  
  128.             {  
  129.                 fos.write(buf,0,len);  
  130.             }  
  131.   
  132.             //将收到图片数据的信息返回给客户端  
  133.             OutputStream out=s.getOutputStream();  
  134.               
  135.             out.write("上传成功！".getBytes());  
  136.   
  137.             fos.close();//关流  
  138.             s.close();  
  139.         }  
  140.         catch (Exception e)  
  141.         {  
  142.             throw new RuntimeException(ip+"图片上传失败");  
  143.         }  
  144.     }  
  145. }  


二、客户端并发登录

        客户端通过键盘录入用户名，服务端对这个用户名进行校验。

        如果该用户存在，在服务端显示xxx，已登陆；并在客户端显示xxx，欢迎光临。

        如果用户不存在，在服务端显示xxx，尝试登陆；并在客户端显示xxx，该用户不存在。

        最多就登录三次。

代码： 

[java]  view plain copy
  1. import java.io.*;  
  2. import java.net.*;  
  3. //客户端  
  4. class  LoginClient  
  5. {  
  6.     public static void main(String[] args) throws Exception  
  7.     {  
  8.         //创建服务  
  9.         Socket s=new Socket("localhost",10000);  
  10.         //键盘录入  
  11.         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  
  12.   
  13.           
  14.         //用Socket服务输出流写入数据  
  15.         PrintWriter out =new PrintWriter(s.getOutputStream(),true );  
  16.   
  17.         //接收服务器返回的信息  
  18.         BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));  
  19.   
  20.         String line=null;  
  21.   
  22.         for(int x=0;x<3;x++)  
  23.         {  
  24.             line=br.readLine();//读取键盘录入  
  25.             if (line==null)  
  26.             {  
  27.                 break;//如果键盘没有输入，则直接结束  
  28.             }  
  29.   
  30.             out.println(line);//将数据写入流中  
  31.   
  32.             String info=in.readLine();//读取返回信息  
  33.   
  34.             System.out.println(info);  
  35.   
  36.             if (info.contains("欢迎"))//---------------  
  37.             {  
  38.                 break;//如果登录成功，就跳出循环  
  39.             }  
  40.         }  
  41.   
  42.         br.close();//关流  
  43.         s.close();  
  44.     }  
  45. }  
  46.   
  47. //服务端  
  48. class LoginServer  
  49. {  
  50.     public static void main(String [] args)throws Exception  
  51.     {  
  52.         //创建服务，监听端口  
  53.         ServerSocket ss=new ServerSocket(10000);  
  54.           
  55.         while (true)  
  56.         {  
  57.             //获取客户端对象  
  58.             Socket s=ss.accept();  
  59.           
  60.             //客户端执行线程  
  61.             new Thread(new LoginThread(s)).start();  
  62.         }  
  63.           
  64.         //ss.close();  
  65.     }  
  66. }  
  67.   
  68. //利用多线程实现并发登录  
  69. class LoginThread implements Runnable  
  70. {  
  71.     private Socket s;  
  72.     LoginThread(Socket s)  
  73.     {  
  74.         this.s=s;  
  75.     }  
  76.     public void run()  
  77.     {  
  78.         //获取客户端ip  
  79.         String ip=s.getInetAddress().getHostAddress();  
  80.         System.out.println(ip+"  connected.....");  
  81.         try  
  82.         {         
  83.             for (int x=0;x<3 ;x++ )  
  84.             {     
  85.                 //通过客户端的读取流读取数据  
  86.                 BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));  
  87.                   
  88.                 //读取数据库中的数据，这里用文件来表示数据库  
  89.                 BufferedReader br=new BufferedReader(new FileReader("users.txt"));  
  90.   
  91.                 String line=in.readLine();//读取客户端数据  
  92.                 if (line==null)//--------------  
  93.                 {  
  94.                     break;//如果客户端没有发送数据，则跳出循环  
  95.                 }  
  96.                 String data=null;  
  97.                 boolean flag=false;//设置标记  
  98.                 //读取数据库中的用户数据  
  99.                 while ((data=br.readLine())!=null)  
  100.                 {  
  101.                     if (line.equals(data))  
  102.                     {  
  103.                         flag=true;//如果用户存在，则将标记设为true  
  104.                         break;  
  105.                     }  
  106.                 }  
  107.   
  108.                 //将数据写入到指定文件中  
  109.                 PrintWriter out=new PrintWriter(s.getOutputStream(),true);  
  110.   
  111.                 if (flag)  
  112.                 {  
  113.                     System.out.println(line+",已登陆！");  
  114.                       
  115.                     out.println(line+"，欢迎光临！");  
  116.   
  117.                     break;//-----------  
  118.                 }  
  119.                 else  
  120.                 {  
  121.                     System.out.println(line+",尝试登陆！");  
  122.                     out.println(line+"，用户名不存在！");  
  123.                 }     
  124.             }  
  125.             s.close();//关流  
  126.         }  
  127.         catch (Exception e)  
  128.         {  
  129.             throw new RuntimeException("用户登陆失败");  
  130.         }     
  131.     }  
  132. }  


三、客户端和服务的浏览器演示

        浏览器是一个标准的客户端，它可以对服务端传送过来的数据消息进行解析，把符合应用层协议的消息部分解析后，将头信息拆包掉，传送到应用层，只保留了正确的正文主题部分显示在主体部分上。

        而由于使用java编译是在传输层和网际层处理的，所以，会接受到全部的消息，包含了头消息。而浏览器处于应用层，已将发送来的头消息去除，只留下了主体信息。

示例：

        自定义服务器，用浏览器访问：

[java]  view plain copy
  1. import java.io.*;  
  2. import java.net.*;  
  3.   
  4. //服务器  
  5. class  ServerDemo  
  6. {  
  7.     public static void main(String[] args)throws Exception   
  8.     {  
  9.         //创建服务，监听端口  
  10.         ServerSocket ss=new ServerSocket(10000);  
  11.         //获取客户端  
  12.         Socket s=ss.accept();  
  13.         //显示ip  
  14.         String ip=s.getInetAddress().getHostAddress();  
  15.   
  16.         System.out.println(ip);  
  17.         //读取客户端读取流数据  
  18.         InputStream in=s.getInputStream();  
  19.   
  20.         byte[] buf=new byte[1024];  
  21.         int len=in.read(buf);  
  22.         //显示数据  
  23.         System.out.println(new String(buf,0,len));  
  24.         //返回信息写入客户端输出流  
  25.         PrintWriter out=new PrintWriter(s.getOutputStream(),true);///true一定要记得写  
  26.   
  27.         out.println("<font color='red' size='7'>客户端你好!</font>");  
  28.   
  29.         s.close();//关流  
  30.         ss.close();  
  31.     }  
  32. }  

 

四、URL和URLConnection

1、URL：

        URI：范围更大，条形码也包含于此范围

        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的查询部，客户端传输的特定信息

注：一般输入网址，是不带端口号的，此时可进行获取，通过获取网址返回的port，若port为-1，则分配一个默认的80端口，如

        int port = getPort();

        if(port == -1)

              port = 80;

2、URLConnection

方法：

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

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

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

示例：

[java]  view plain copy
  1. /* 
  2. 自定义浏览器，显示网页信息 
  3. */  
  4.   
  5. import java.io.*;  
  6. import java.awt.*;  
  7. import java.awt.event.*;  
  8. import java.net.*;  
  9.   
  10. class MyIEGUIDemo  
  11. {  
  12.     //定义所需组件引用  
  13.     private Frame f;  
  14.     private Button but,bok;  
  15.     private TextField tf;  
  16.     private TextArea ta;  
  17.   
  18.     //构造函数  
  19.     MyIEGUIDemo()  
  20.     {  
  21.         init();  
  22.     }  
  23.   
  24.     //窗体基本设置于功能实现  
  25.     public void init()  
  26.     {  
  27.         //组件实例化  
  28.         f=new Frame("我的Window");  
  29.         but=new Button("跳转");  
  30.         tf=new TextField(50);  
  31.         ta=new TextArea(25,60);  
  32.   
  33.         //基本设置  
  34.         f.setBounds(300,150,500,500);  
  35.         f.setLayout(new FlowLayout());  
  36.   
  37.         //添加组件  
  38.         f.add(tf);  
  39.         f.add(but);  
  40.         f.add(ta);  
  41.   
  42.         //窗体事件  
  43.         myEvent();  
  44.   
  45.         //窗体显示  
  46.         f.setVisible(true);  
  47.     }  
  48.   
  49.     //注册事件  
  50.     public void myEvent()  
  51.     {  
  52.         //窗体关闭功能  
  53.         f.addWindowListener(new WindowAdapter()  
  54.         {  
  55.             public void windowClosing(WindowEvent e)  
  56.             {  
  57.                 System.exit(0);  
  58.             }  
  59.         });  
  60.   
  61.         //“跳转”按钮事件  
  62.         but.addActionListener(new ActionListener()  
  63.         {  
  64.             public void actionPerformed(ActionEvent e)  
  65.             {  
  66.                 showFile();//显示网页内容在文本区中  
  67.             }  
  68.         });  
  69.   
  70.           
  71.   
  72.         //文本框键盘事件  
  73.         tf.addKeyListener(new KeyAdapter()  
  74.         {  
  75.             public void keyPressed(KeyEvent e)  
  76.             {  
  77.                 //如果键盘按下Enter键，就将网页内容显示在文本区中  
  78.                 if(e.getKeyCode()==KeyEvent.VK_ENTER)  
  79.                     showFile();  
  80.             }  
  81.         });  
  82.     }  
  83.   
  84.     //显示网页内容  
  85.         private void showFile()  
  86.         {  
  87.             ta.setText("");  
  88.             String path=tf.getText();//获取输入的路径  
  89.             try  
  90.             {  
  91.                 //封装地址对象  
  92. URL url =new URL(path);  
  93. 连接网页服务器  
  94.                 URLConnection conn=url.openConnection();  
  95.                 //读取流，用于读取服务器返回数据  
  96.                 InputStream in=conn.getInputStream();  
  97.   
  98.                 byte[] buf=new byte[1024*1024];  
  99.   
  100.                 int len=in.read(buf);  
  101.                 //将数据显示在文本区中  
  102.                 ta.append(new String(buf,0,len));  
  103.             }  
  104.             catch (Exception e)  
  105.             {  
  106.                 throw new RuntimeException("连接"+path+"网站失败");  
  107.             }  
  108.         }  
  109.   
  110.     public static void main(String[] args)   
  111.     {  
  112.         //运行窗体  
  113.         new MyIEGUIDemo();  
  114.     }  
  115. }  

 

小知识点

1、Socket类的构造函数中，有一个空参数的构造函数：

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

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

2、ServerSocket对象中的构造函数：

        ServerSocket(int port,int backlog)，其中的backlog表示队列的最大长度，即最多连入客户端的个数，即最大连接数。

3、在浏览器输入网址访问一台主机所做的操作：

       如输入http://61.135.169.125，可以直接连接此ip的主机，而我们一般是输入主机名：http:/www.baidu.ocm（百度主机对应的ip地址就是：61.135.169.125），那么此时浏览器做了神马操作呢？

       也就是说如何通过主机名获取IP地址，从而连接到这台主机呢？这就需要将主机名翻译成IP地址，即域名解析：DNS

        在进行访问的时候，会先在本地的hosts文件（c:\windows\system32\drivers\ext\host）中找对应的映射。若有，则直接返回请求；若无，则到公网的映射列表即DNS中找对应的映射，找到后，将主机名对应的IP地址返回给本机，本机通过这个IP地址找到对应的服务器。

示意图：

 host应用：可屏蔽一些恶意网址，即将对应的映射关系写入hosts中，将IP地址改为本机的回环地址，那么会直接找到hosts，就不会将请求发送出去了。

 
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29480345/article/details/47251577

智能推荐

1.1 《数据库系统概论》之数据库系统概述（数据、数据库、数据库管理系统、数据库系统、数据库的产生和发展）_金融大数据技术与应用-程序员宅基地

文章浏览阅读6.4w次，点赞416次，收藏789次。文章目录0.思维导图1.四大基本概念（1）数据--Data① 数据的定义② 数据的种类③ 数据的特点④ 数据举例（2）数据库--Database① 数据库的定义② 数据库的基本特征（3）数据库管理系统--DataBase Management System① 什么是DBMS?② DBMS的用途③ DBMS的主要功能（4）数据库系统--Database System① 什么是数据库系统（Databa..._金融大数据技术与应用

打造个性化聊天机器人：本地部署大语言模型Llama2点实战解析_用c# 写一个界面 调用llama2 大模型实现对话-程序员宅基地

文章浏览阅读626次，点赞4次，收藏8次。随着人工智能技术的迅猛发展，大语言模型正逐渐渗透到我们生活的方方面面，从智能客服到写作助手，再到虚拟助手，它们以其强大的自然语言处理能力，为我们提供了前所未有的便捷与智能体验。然而，大部分大语言模型产品都基于网络线上运行，对于希望拥有自己个性化聊天机器人的用户来说，如何在本地部署一个高效的大语言模型，成为了一个颇具挑战性的问题。近期，一款名为Llama 2的大语言模型引起了广泛关注。Llama 2是一款开源的大语言模型，其训练数据量已达到7B级别，在上下文长度为4K下的单轮与多轮对话中表现出色。_用c# 写一个界面 调用llama2 大模型实现对话

hdu 1754 I Hate It 线段树单点更新区间查询-程序员宅基地

文章浏览阅读207次。题目：I Hate ItTime Limit: 9000/3000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 69414 Accepted Submission(s): 26895Problem Description很多学校流

c语言怎么把数字倒过来_c语言中如何实现输入一个整数实现倒序输出-程序员宅基地

文章浏览阅读1.4w次，点赞9次，收藏9次。展开全部定义一个整数类型的输入,然后让它正序输出,倒序输出相32313133353236313431303231363533e78988e69d8331333366303833信是很多C语言初学入门一定会遇到的经典题目,下面就是我对整数的正序和倒序输出一点小小的总结.1. 反序(倒序)输出反序输出常用的思路就是按位取余,把取出来的值进行循环保存。int main(){int i=12345; //..._c语言怎么把数字倒过来

Arduino-Esp8266。出现两种问题记录。_could not open port 'com3': filenotfounderror(2, '-程序员宅基地

文章浏览阅读4k次。自我记录学习——1Arduino 上传代码到Esp8266-01s上出现的问题和解决方法（个人纪录）使用USB转TTL与Esp8266连接上传代码时，出现解决办法使用传统Arduino UNO，面包板连线的方式出现解决方法Arduino 上传代码到Esp8266-01s上出现的问题和解决方法（个人纪录）使用USB转TTL与Esp8266连接上传代码时，出现esptool.py v2.8Serial port COM3Traceback (most recent call last): Fil_could not open port 'com3': filenotfounderror(2, '系统找不到指定的文件。', n

python环境做C语言分析-pycparser的使用方法（1）-程序员宅基地

文章浏览阅读7.4k次，点赞6次，收藏33次。pycparser是纯Python代码编写的C语言解析器。本文章介绍了pycparser安装、使用方法、语法树节点属性分析以及实践案例等内容。希望对静态代码分析工作提供一些帮助。_pycparser

随便推点

Python入门必学：Python编程语言的特点和优点-程序员宅基地

文章浏览阅读980次，点赞25次，收藏26次。 深入探索Python：语言特点与优势 Python，这种独特的编程语言，以其简洁、易读和强大的功能而闻名。其面向对象、解释型以及跨平台的特性，使得Python在多个领域都有广泛应用。 Python的魅力在于其丰富的库和框架，如NumPy、Pandas等，为数据分析、机器学习等提供了便捷。同时，Python的社区支持也是其一大亮点，吸引了全球众多开发者。 总结来说，Python是一种功能强大、易于上手且拥有广泛应用的编程语言。

看完就知道日通国际搬家公司为什么那么贵，不会担心物品在运的过程中会损坏或变形...-程序员宅基地

文章浏览阅读264次。有用过日通都觉得比较贵，今天日通来给大家介绍下为什么国际搬家的服务会比较贵的原因是什么呢？日通是定位在高端搬家，提供一站式、用户不用动手的搬家业务。提供收纳、拆装和收纳，到搬运新家物品还原。整个过程用户不需要提前收拾东西和到了新家再还原好，只需要把钥匙给日通公司即可。一.国际极致的服务：1.搬家前提前踩点做规划搬家前，只要给公司打个电话，他们就会立即派遣督导上门，将你的物品分门别类，然后列出..._国际搬家破损严重

Unity3D图像后处理特效——Contrast Enhance_ce就是contrast enhance-程序员宅基地

文章浏览阅读4.4k次。The Contrast Enhance image effect enhances the impression of contrast for a given camera. It uses the well-knownunsharp mask process available in image processing applications.对于一个特定的相机，对比度增强特效可以增_ce就是contrast enhance

Latex BIB引用硕士论文、博士论文格式_latex中引用博士学位论文-程序员宅基地

文章浏览阅读3.6k次。博士@phdthesis{citekey, author = "", title = "", school = "", year = ""}硕士@mastersthesis{citekey, author = "", title = "", school = "", year = ""}_latex中引用博士学位论文

真象还原操作系统_第十章_输入输出系统_操作系统真象还原第十章-程序员宅基地

文章浏览阅读846次，点赞26次，收藏23次。这种行为是由于编译器的链接过程所决定的。当编译器处理一个源文件时，它会将其中定义的函数和变量与其他源文件的函数和变量进行链接。而带有static关键字的函数具有内部链接（internal linkage），只能在定义它的源文件中使用。当static用于函数时，它会使函数的作用域限定在当前源文件中，也就是说，该函数只能在定义它的源文件中使用，无法被其他源文件调用。输入缓冲区寄存器：8位宽寄存器，键盘驱动程序通过out指令向此寄存器写入对8048的控制命令、参数等，对于8042本身的控制命令也是写入此寄存器。_操作系统真象还原第十章

北京信息科技大学第十五届程序设计竞赛（同步赛）解题报告(流水账版) | 珂学家_北京信息科技大学第十五届程序设计竞赛答案-程序员宅基地

文章浏览阅读827次，点赞19次，收藏22次。两个offer都是奔着挣钱去的，长春跟上海离家差不多近，上海虽然郊区消费还是比长春高，华为卫星工资都统一价的样子，华为工资应该略高卫星，加班强度远大于卫星，加薪。本人浙江双飞硕小菜鸡一枚，家在宁波，秋招一开始也投省内互联网，投到后来发现互联网强度有点大，观念也转变了，感觉挣多少钱都是要回家的，后面主要就冲宁波地区了，现在。鼠鼠是个小二本，面试机会两只手数的清，想在秋招前找个好点的实习啊 #实习，投递多份简历没人回复怎么办# #简历被挂麻了，求建议# #简历中的项目经历要怎么写。_北京信息科技大学第十五届程序设计竞赛答案

推荐文章

热门文章

相关标签