网络编程

网络编程

一、网络编程概述

    网络编程：可以在不同网络终端上通信的编程。

    网络通讯三要素：IP地址、端口号、传输协议。

    IP地址：标识通信双方计算机，简单说：标识对方，找到对方；在java中，IP封装成为InetAddress类；本地回环地址：127.0.0.1，主机名为localhost。

    端口号：用于标识进程的逻辑地址，即不同进程的标识；有效端口号：0—65535，其中0—1024系统使用或者为保留端口，Tomcat服务器默认端口为8080，Web服务为80。

    传输协议：通信双方的数据遵循规则必须一致，否则无法通信；网络上用TCP/IP协议。

    网络之间的通信是一个很复杂的过程，为了把复杂事物简单化，网络可以理论分为七个参考模型(OSI)：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层；也可以按TCP/IP(实际应用的模型)分为四层：网络接口层、网络层、传输层、应用层。

    常见的协议：网络层：IP；传输层：TCP、UDP；应用层：HTTP、FTP等。

    总之：发送方：是一个数据封包的过程；接收方：是一个数据解包的过程。

    UDP和TCP是运输层的两个不同协议，UDP面向无连接，TCP面向连接；区别如下：

    UDP：1、将数据及源和目的封装成数据包，不需要建立连接；2、每个数据包的大小限制在64K内；3、因为无连接，数据通信不可靠；4.因为不需要建立连接，所以速度快。

    TCP：1、需要建立连接，形成传输数据的通道；2、在通道中进行大数据的传输；3、通过三次握手完成连接，数据通信可靠；4、因为需要建立连接，所以效率稍低。

    Socket：socket是为网络服务提供的一种机制。好比水运的码头，想要运输货物，必须先建立好码头，同理,想要进行网络传输，必须先建立Socket接口；码头有专门为客船服务的，也有专门为军事服用的，同理，Socket有专门为UDP类型传输的，也有专门为TCP类型传输的；所以，根据不同的需要建立不同的Socket接口。

二、UDP传输

    UDP传输：面向无连接的传输，传输数据的两端分为发送端和接收端，“码头”为DatagramSocket，在“码头”上运送的数据封装对象Datagrampacket，想获取具体的数据，可以通过DatagramPacket类中的相应方法获取。

    注意：要发送的数据包必须带上地址，即：明确目的地IP、端口；接收端必须指明端口，发送端可以不指定端口，系统会分配默认的端口。

    思路：网路编程重要的就是思路，具体对象可以查阅API

    UDP发送端：

    1、建立udpsocket服务；

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

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

    4、关闭资源。

    UDP接收端：

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

    2、定义一个数据包，存储接收到的字节数据；

    3、通过socket服务的receive方法接收到的数据存入指定的数据包中；

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

    5、关闭资源。

下面代码演示：

1、发送端发送数据到接收端

发送端：

[java]  view plain copy

1. package itheima.day23;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStreamReader;  
6. import java.net.DatagramPacket;  
7. import java.net.DatagramSocket;  
8. import java.net.InetAddress;  
9. import java.net.SocketException;  
10.   
11. public class udpSend2 {  
12.   
13.     public static void main(String[] args) throws IOException {  
14.           
15.         DatagramSocket ds = new DatagramSocket();  
16.         BufferedReader bufr =  
17.                 new BufferedReader(new InputStreamReader(System.in));  
18.           
19.         String line = null;  
20.         while((line = bufr.readLine())!=null){  
21.             if("886".equals(line))  
22.                 break;  
23.             byte[] buf = line.getBytes();  
24.               
25.             DatagramPacket dp =   
26.                     new DatagramPacket(buf,buf.length,InetAddress.getByName("100.64.37.118"),10017);  
27.             ds.send(dp);  
28.         }  
29.         ds.close();  
30.     }  
31. }  

接收端：

[java]  view plain copy

1. package itheima.day23;  
2.   
3. import java.io.IOException;  
4. import java.net.DatagramPacket;  
5. import java.net.DatagramSocket;  
6. import java.net.SocketException;  
7.   
8. public class UdpRece2 {  
9.   
10.     public static void main(String[] args) throws IOException {  
11.           
12.         DatagramSocket ds = new DatagramSocket(10017);  
13.           
14.         while(true){  
15.             byte[] buf = new byte[1024];  
16.             DatagramPacket dp = new DatagramPacket(buf,buf.length);  
17.             ds.receive(dp);//阻塞式方法  
18.             String ip = dp.getAddress().getHostAddress();  
19.             String data = new String(dp.getData(),0,dp.getLength());  
20.             int port = dp.getPort();  
21.             System.out.println(ip+":::"+data+":::"+port);  
22.         }  
23.     }  
24. }  

2、简单聊天程序：

[java]  view plain copy

1. package itheima.day23;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStreamReader;  
6. import java.net.DatagramPacket;  
7. import java.net.DatagramSocket;  
8. import java.net.InetAddress;  
9. import java.net.SocketException;  
10.   
11. //需求：编写一个聊天程序。  
12. public class ChatDemo {  
13.   
14.     public static void main(String[] args) throws SocketException {  
15.           
16.         DatagramSocket sendSocket = new DatagramSocket();  
17.         DatagramSocket receSocket = new DatagramSocket(10005);  
18.           
19.         new Thread(new Send(sendSocket)).start();  
20.         new Thread(new Recv(receSocket)).start();  
21.     }  
22. }  
23.   
24. class Send implements Runnable{  
25.       
26.     private DatagramSocket ds;  
27.     Send(DatagramSocket ds){  
28.         this.ds = ds;  
29.     }  
30.       
31.     @Override  
32.     public void run() {  
33.         try {     
34.             BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
35.             String line = null;  
36.             while((line = bufr.readLine())!=null){  
37.                 if("886".equals(line))  
38.                     break;  
39.                 byte[] buf = line.getBytes();  
40.                 DatagramPacket dp =   
41.                         new DatagramPacket(buf,buf.length,InetAddress.getByName("100.64.37.118"),10005);  
42.                 ds.send(dp);  
43.             }  
44.         } catch (IOException e) {  
45.             throw new RuntimeException("发送端失败");  
46.         }  
47.     }  
48. }  
49.   
50. //接收端  
51. class Recv implements Runnable{  
52.   
53.     private DatagramSocket ds;  
54.     Recv(DatagramSocket ds){  
55.         this.ds = ds;  
56.     }  
57.       
58.     @Override  
59.     public void run() {  
60.         while(true){  
61.             byte[] buf = new byte[1024];  
62.             DatagramPacket dp = new DatagramPacket(buf,buf.length);//接收数据的包  
63.             try {  
64.                 ds.receive(dp);  
65.                 String ip = dp.getAddress().getHostAddress();  
66.                 String data = new String(dp.getData(),0,dp.getLength());  
67.                   
68.                 System.out.println(ip+"::"+data);  
69.                   
70.             } catch (IOException e) {  
71.                 throw new RuntimeException("接收端失败");  
72.             }  
73.         }  
74.     }     
75. }  

三、TCP传输

    TCP传输：TCP是面向连接的传输，分为客户端和服务端，客户端对应的对象是Socket，服务端对应的对象是ServerSocket。

    客户端：socket对象在建立时，就可以去连接指定的主机，因为tcp是面向连接的，所以建立socket服务时，就要有服务端存在，并连接成功，形成通路后，在通道上进行数据的传输。

    服务端：专门给客户端提供服务，采用多线程技术同时给多个客户请求提供服务，大型的服务器一般不关闭，例如：新浪。

    思路：

    TCP客户端：

    1、创建socket服务，并指定要链接的主机和端口；

    2、获取socket流中的输出流，将数据写到该流中，通过网络发送给服务端；

    3、获取socket流中的输入流，将服务端返回的数据获取到，并打印；

    4、关闭客户端。

    TCP服务端：

    1、建立服务端的socket服务，ServerSocket()，并监听一个端口；

    2、获取链接过来的客户端的对象，通过ServerSocket的accept方法，阻塞式方法 ；

    3、客户端如果发过来数据，那么服务端要使用对应的客户端对象，获取数据；

    4、关闭服务端（可选）。

    注意：客户端和服务端都莫名的等待，那是因为客户端和服务端都有阻塞式方法，这些方法没有读到结束标记，一直等待的缘故。

    域名解析原理：当在浏览器中输入一个域名时，浏览器会先去C:\Windows\System32\drivers\etc hosts 文件查找是否有对应的ip地址；若没有，再去公网的DNS服务器去查询，当获得了域名对应的ip地址后，再根据ip地址去访问具体的网页，最终还是用ip是访问网页。其中DNS服务器我们可以自行设置，默认时，走的是最近的DNS服务器。

下面代码体现：

3、演示客户端与服务端

客户端：

[java]  view plain copy

1. package itheima.day23;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5. import java.io.OutputStream;  
6. import java.net.Socket;  
7. import java.net.UnknownHostException;  
8.   
9. //演示tcp传输的客户端和服务端的互访  
10. // 需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。  
11. public class TCPClient2 {  
12.   
13.     public static void main(String[] args) throws UnknownHostException, IOException {  
14.           
15.         Socket s = new Socket("100.64.86.48",10012);  
16.         OutputStream out = s.getOutputStream();  
17.         out.write("服务端，服务端，我是客户端".getBytes());  
18.         InputStream in = s.getInputStream();  
19.           
20.         byte[] buf = new byte[1024];  
21.         int len = in.read(buf);//阻塞式方法  
22.         System.out.println(new String(buf,0,len));  
23.         s.close();  
24.     }  
25. }  

服务端：

[java]  view plain copy

1. package itheima.day23;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5. import java.io.OutputStream;  
6. import java.net.ServerSocket;  
7. import java.net.Socket;  
8.   
9. public class TCPServer2 {  
10.   
11.     public static void main(String[] args) throws IOException {  
12.           
13.         ServerSocket ss = new ServerSocket(10012);  
14.         Socket s = ss.accept();  
15.         String ip = s.getInetAddress().getHostAddress();  
16.         System.out.println(ip+".....connected");  
17.         InputStream in = s.getInputStream();  
18.           
19.         byte[] buf = new byte[1024];  
20.         int len = in.read(buf);  
21.         System.out.println(new String(buf,0,len));  
22.           
23.         OutputStream out = s.getOutputStream();  
24.         out.write("客户端，客户端，服务端收到".getBytes());  
25.         s.close();  
26.         ss.close();  
27.     }  
28.   
29. }  

4、建立一个文本转换服务器，服务端将客户端发送来的文本转成大写回给客户端

客户端：

[java]  view plain copy

1. package itheima.day23;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.BufferedWriter;  
5. import java.io.IOException;  
6. import java.io.InputStreamReader;  
7. import java.io.OutputStreamWriter;  
8. import java.io.PrintWriter;  
9. import java.net.Socket;  
10. import java.net.UnknownHostException;  
11.   
12. //需求：建立一个文本转换服务器，服务端将客户端发送来的文本转成大写回给客户端。  
13. //      客户端可以不断的进行文本转换，当客户端输入over时，转换结束  
14. //步骤：1、建立服务，2、获取键盘录入，3、将数据发给服务端，  
15. // 4、获取服务端回给的大写数据，5.结束，关闭资源。  
16.    
17. public  class TransClient {  
18.   
19.     public static void main(String[] args) throws UnknownHostException, IOException {  
20.         Socket s = new Socket("100.64.86.48",10021);  
21.         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
22. //      打印流，打印的目的：Socket对象的输出流，自动刷新  
23.         PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
24. //      BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
25.         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
26.         String line = null;  
27.         while((line = bufr.readLine())!=null){  
28.             if("over".equals(line))  
29.                 break;    
30.             out.println(line);  
31.               
32. //          bufOut.write(line);//写到输出流中  
33. //          bufOut.newLine();//结束标记  
34. //          bufOut.flush();  
35.             String str = bufIn.readLine();  
36.             System.out.println("Server:"+str);  
37.         }  
38.     }  
39. }  

服务端：

[java]  view plain copy

1. package itheima.day23;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.BufferedWriter;  
5. import java.io.IOException;  
6. import java.io.InputStreamReader;  
7. import java.io.OutputStreamWriter;  
8. import java.io.PrintWriter;  
9. import java.net.ServerSocket;  
10. import java.net.Socket;  
11.   
12. //服务端：源：socket读取流；目的：socket输出流  
13. public class TransServer {  
14.   
15.     public static void main(String[] args) throws IOException  {  
16.           
17.     ServerSocket ss = new ServerSocket(10021);  
18.     Socket s = ss.accept();  
19.     String ip = s.getInetAddress().getHostAddress();  
20.     System.out.println(ip+"....connected");  
21.     BufferedReader bufIn =   
22.             new BufferedReader(new InputStreamReader(s.getInputStream()));  
23.     PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
24. //  BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
25.       
26.     String line = null;  
27.     while((line = bufIn.readLine())!=null){  
28.         System.out.println("client:"+line);  
29.           
30.         out.println(line.toUpperCase());  
31.           
32. //      bufOut.write(line.toUpperCase());  
33. //      bufOut.newLine();  
34. //      bufOut.flush();       
35.     }  
36.     s.close();  
37.     ss.close();  
38.       
39.     }  
40. }  

5、将一个文本上传给服务器：

客户端：

[java]  view plain copy

1. package itheima.day23;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.FileReader;  
5. import java.io.IOException;  
6. import java.io.InputStreamReader;  
7. import java.io.PrintWriter;  
8. import java.net.Socket;  
9. import java.net.UnknownHostException;  
10.   
11. public class TextClient {  
12.   
13.     public static void main(String[] args) throws UnknownHostException, IOException {  
14.           
15. <span style="white-space:pre">  </span> Socket s = new Socket("100.64.86.48",10007);  
16.         BufferedReader bufr =   
17.                 new BufferedReader(new FileReader("4.txt"));  
18.         PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
19.           
20.         String line = null;  
21.         while((line = bufr.readLine())!=null){  
22.             out.println(line);  
23.         }  
24.         s.shutdownOutput();  
25.         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
26.         String str = bufIn.readLine();  
27.         System.out.println("server:"+str);  
28.         bufr.close();  
29.         bufIn.close();  
30.         out.close();  
31.         s.close();    
32.     }  
33. }  

服务端：

[java]  view plain copy

1. package itheima.day23;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.FileWriter;  
5. import java.io.IOException;  
6. import java.io.InputStreamReader;  
7. import java.io.PrintWriter;  
8. import java.net.ServerSocket;  
9. import java.net.Socket;  
10.   
11. public class TextServer {  
12.   
13.     public static void main(String[] args) throws IOException {  
14.           
15.         ServerSocket ss = new ServerSocket(10007);  
16.         Socket s = ss.accept();  
17.           
18.         String ip = s.getInetAddress().getHostAddress();  
19.         System.out.println(ip+".....connected");  
20.         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
21.         PrintWriter out = new PrintWriter(new FileWriter("Server.txt"),true);  
22.       
23.         String line = null;  
24.         while((line = bufIn.readLine())!=null){   
25.             out.println(line);  
26.         }  
27.           
28.         PrintWriter pw = new PrintWriter(s.getOutputStream(),true);  
29.         pw.println("恭喜。上传成功！");  
30.         s.close();  
31.         ss.close();  
32.     }  
33. }  

6、给服务器上传图片

客户端：

[java]  view plain copy

1. package itheima.day24;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.io.OutputStream;  
8. import java.net.Socket;  
9. import java.net.UnknownHostException;  
10. /*客户端： 
11.  * 1、服务端点 
12.  * 2、读取客户端已有的图片数据 
13.  * 3、通过socket 输出流将数据发送给服务端 
14.  * 4、读取服务端反馈信息 
15.  * 5、关闭资源 
16.  * */  
17. public class PictureClient {  
18.   
19.     public static void main(String[] args) throws UnknownHostException, IOException {  
20.         /* 
21.         if(args.length != 1){ 
22.             System.out.println("请选择一个jpg格式的图片"); 
23.             return ; 
24.         } 
25.          
26.         File file = new File(args[0]); 
27.          
28.         if(!(file.exists() && file.isFile())){ 
29.             System.out.println("该文件有问题"); 
30.             return ; 
31.         } 
32.          
33.         if(!file.getName().endsWith(".jpg")){ 
34.             System.out.println("图片格式有误，请重新选择"); 
35.             return ; 
36.         } 
37.          
38.         if(file.length() > 5*1024*1024){ 
39.             System.out.println("文件过大，不安好心"); 
40.         } 
41.         */  
42.           
43.         Socket s = new Socket("100.64.15.72",10007);  
44.         File file = new File("1.jpg");  
45.           
46.         FileInputStream fis = new FileInputStream(file);  
47.         OutputStream out = s.getOutputStream();  
48.           
49.         byte[] buf = new byte[1024];  
50.         int len = 0;  
51.         while((len = fis.read(buf))!=-1){  
52.             out.write(buf,0,len);  
53.         }  
54. //      关闭Socket服务的输出流，结束标记  
55.         s.shutdownOutput();  
56.           
57.         InputStream in = s.getInputStream();  
58.         byte[] bufIn = new byte[1024];  
59.           
60.         int num = in.read(bufIn);  
61.         System.out.println(new String(bufIn,0,num));  
62.           
63.         fis.close();  
64.         s.close();  
65.     }  
66. }  

服务端：

[java]  view plain copy

1. package itheima.day24;  
2.   
3. import java.io.File;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.io.OutputStream;  
8. import java.net.ServerSocket;  
9. import java.net.Socket;  
10.   
11. //所有的服务器都是这个原理  
12. public class PicServer {  
13.   
14.     public static void main(String[] args) {  
15.         ServerSocket ss = null;  
16.         try {  
17.             ss = new ServerSocket(10007);  
18.         } catch (IOException e) {  
19.             e.printStackTrace();  
20.         }  
21.         while(true){  
22.             Socket s = null;  
23.             try {  
24.                 if(ss!=null)  
25.                     s = ss.accept();//阻塞式方法  
26.             } catch (IOException e) {  
27.                 e.printStackTrace();  
28.             }  
29.             new Thread(new PicThread(s)).start();  
30.         }  
31.     }  
32. }  
33.   
34. //其实实现Runnable接口的子类，就是线程要执行的目标  
35. //只是作为构造参数传给Thread类罢了  
36. //每一个任务里面都有一个Socket服务为连接进来的客户服务  
37. class PicThread implements Runnable{  
38.       
39.     private Socket s;  
40.     PicThread(Socket s){  
41.         this.s = s;  
42.     }  
43.       
44.     @Override  
45.     public void run() {  
46.           
47.         int count = 1;  
48.         String ip = s.getInetAddress().getHostAddress();  
49.         try{  
50.             System.out.println(ip+"....connected");  
51.               
52.             InputStream in = s.getInputStream();  
53.               
54.             File file = new File(ip+"("+count+")"+".jpg");  
55.               
56.             while(file.exists()){  
57.                 file = new  File(ip+"("+(count++)+")"+".jpg");  
58.             }  
59.               
60.             FileOutputStream fos = new FileOutputStream(file);  
61.               
62.             byte[] buf = new byte[1024];  
63.             int len = 0;  
64.             while((len = in.read(buf))!=-1){  
65.                 fos.write(buf, 0, len);  
66.             }  
67.             OutputStream out = s.getOutputStream();  
68.               
69.             out.write("恭喜，上传成功".getBytes());  
70.               
71.             fos.close();  
72.             s.close();  
73.         }catch(Exception e){  
74.             throw new RuntimeException(ip+"上传失败");  
75.         }  
76.     }  
77. }  

7、模拟用户的登陆

客户端：

[java]  view plain copy

1. package itheima.day24;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStreamReader;  
6. import java.io.PrintWriter;  
7. import java.net.Socket;  
8. import java.net.UnknownHostException;  
9.   
10. //客户端通过键盘录入用户名，服务端对这个用户进行校验  
11. // 如果该用户存在，在服务端显示xxx，已登录；并在客户端显示xxx，欢迎光临  
12. // 如果该用户存在，在服务端显示xxx，尝试登陆；并在客户端显示xxx，用户不存在。  
13. // 最多三次  
14. public class LoginClient {  
15.   
16.     public static void main(String[] args) throws UnknownHostException, IOException {  
17.           
18.         Socket s = new Socket("100.64.15.72",10008);  
19.         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
20.         PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
21.         BufferedReader bufIn =   
22.                 new BufferedReader(new InputStreamReader(s.getInputStream()));  
23.           
24.         for(int x = 0;x<3;x++){  
25.             String line = bufr.readLine();  
26.             if(line == null)  
27.                 break;  
28.             out.println(line);  
29.           
30.             String info = bufIn.readLine();  
31.             System.out.println("info::"+info);  
32.               
33.             if(info.contains("欢迎"))  
34.                 break;  
35.         }  
36.         bufr.close();  
37.         s.close();  
38.     }  
39. }  

服务端：

[java]  view plain copy

1. package itheima.day24;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.FileReader;  
5. import java.io.IOException;  
6. import java.io.InputStreamReader;  
7. import java.io.PrintWriter;  
8. import java.net.ServerSocket;  
9. import java.net.Socket;  
10.   
11. public class LoginServer {  
12.   
13.     public static void main(String[] args) throws IOException {  
14.           
15.         ServerSocket ss = new ServerSocket(10008);  
16.         while(true){  
17.             Socket s = ss.accept();   
18.             new Thread(new UserThread(s)).start();  
19.         }  
20.     }  
21. }  
22.   
23. class UserThread implements Runnable  
24. {  
25.     private Socket s;  
26.     UserThread(Socket s){  
27.         this.s = s;  
28.     }  
29.       
30.     @Override  
31.     public void run() {  
32.           
33.         String ip = s.getInetAddress().getHostAddress();  
34.         System.out.println(ip+"....connected");  
35.           
36.         try {  
37.             for(int x = 0;x<3;x++){  
38.                   
39.                 BufferedReader bufIn =   
40.                         new BufferedReader(new InputStreamReader(s.getInputStream()));  
41.                 String name = bufIn.readLine();  
42.                 if(name == null)  
43.                     break;  
44.                 BufferedReader bufr =   
45.                         new BufferedReader(new FileReader("user.txt"));  
46.                 PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
47.                   
48.                 String line = null;  
49.                 boolean flag = false;  
50.                 while((line = bufr.readLine())!=null){  
51.                 if(line.equals(name)){  
52.                     flag = true;  
53.                     break;  
54.                 }     
55.             }  
56.             if(flag){  
57.                 System.out.println(name+",已登录");  
58.                 out.println(name+",欢迎光临");  
59.                 break;  
60.             }else{  
61.                 System.out.println(name+"尝试登陆");  
62.                 out.println(name+"用户名不存在");  
63.                 }  
64.             }   
65.             s.close();  
66.         } catch (IOException e) {  
67.             e.printStackTrace();  
68.         }  
69.     }     
70. }  

8、定义一个服务器给浏览器提供服务：

[java]  view plain copy

1. package itheima.day24;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5. import java.io.PrintWriter;  
6. import java.net.ServerSocket;  
7. import java.net.Socket;  
8.   
9. /* 
10.  演示客户端和服务端 
11.  1、 
12.   客户端：浏览器 
13.   服务端：自定义 
14.  2、 
15.   客户端：浏览器 
16.   服务端：Tomcat服务器 
17.  */  
18. public class ServerDemo {  
19.   
20.     public static void main(String[] args) throws IOException {  
21.           
22.         ServerSocket ss = new ServerSocket(11000);  
23.           
24.         Socket s = ss.accept();  
25.           
26.         System.out.println(s.getInetAddress().getHostAddress());  
27.           
28.         InputStream in = s.getInputStream();  
29.           
30.         byte[] buf = new byte[1024*1024];  
31.         int len = in.read(buf);  
32.           
33.         System.out.println(new String(buf,0,len));  
34.         PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
35.         out.println("客户端你好");  
36.           
37.         s.close();  
38.         ss.close();  
39.           
40.     }  
41.   
42. }  
43. /* 
44.   HTTP的请求消息头 
45. GET / HTTP/1.1    请求方式； 1.1版本 
46. Accept: text/html, application/xhtml+xml,等等； 接收的类型 
47. Accept-Language: zh-CN 支持的语言 
48. User-Agent: Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; Trident/6.0) 
49. Accept-Encoding: gzip, deflate 可接受的编码 
50. Host: 100.64.130.205:11000 
51. DNT: 1 
52. Connection: Keep-Alive 
53.  */  

9、socket走的都是传输层，URLConnection中封装了socket流，走的是应用层：

[java]  view plain copy

1. package itheima.day24;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5. import java.net.MalformedURLException;  
6. import java.net.URL;  
7. import java.net.URLConnection;  
8.   
9. public class URLConnectionDemo {  
10.   
11.     public static void main(String[] args) throws IOException {  
12.           
13.         URL url = new URL("http://www.baidu.com/s?wd=java%E5%9F%B9%E8%AE%AD&ie=utf-8");  
14. //      走的是应用层，传输层把消息头拆包了，应用层收到的只是数据体  
15.         URLConnection conn =url.openConnection();  
16.         System.out.println(conn);  
17.   
18.         InputStream in = conn.getInputStream();  
19.         byte[]   buf = new  byte[1024*1024];  
20.         int len = in.read(buf);  
21. //      接收到的数据没有消息头  
22.         System.out.println(new String(buf,0,len));  
23.     }  
24.