黑马程序员_网络篇之二_加强篇

　------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

一、用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 print ?

1. <span style="font-size:14px;">/*  
2. 需求：并发上传图片  
3. */  
4. import java.io.*;  
5. import java.net.*;  
6. class  PicSocket  
7. {  
8.     public static void main(String[] args) throws Exception  
9.     {  
10.         if(args.length!=1){  
11.             System.out.println("请选择单个文件上传");  
12.             return;  
13.         }  
14.         //创建socket服务  
15.         Socket s = new Socket("127.0.0.1",1005);  
16.         //从控制台接收一个文件路径  
17.         File file = new File(args[0]);  
18.   
19.         if(!(file.exists()&&file.isFile)){  
20.             System.out.println("您上传的文件可能不存在");  
21.             return;  
22.         }  
23.         if(file.length=>1024*1024*5){  
24.             System.out.println("您上传到文件不能超过5M");  
25.             return;  
26.         }  
27.         if(!(file.getName().endsWith(".jpg"))){  
28.             System.out.println("您只能上传.jpg文件');  
29.         }  
30.   
31.   
32.   
33.         //创建本地读取流，关联文件  
34.         BufferedInputStream bufi =   
35.             new BufferedInputStream(new FileInputStream(file));  
36.         //定义目的，将数据写入socket流，并传输到客户端  
37.         BufferedOutputStream bufo =   
38.             new BufferedOutputStream(s.getOutputStream());  
39.         //定义读取服务端反馈信息流  
40.         BufferedReader bufr =  
41.             new BufferedReader(new InputStreamReader(s.getInputStream()));  
42.         //开始读取数据  
43.         int len = 0;  
44.         while((len=bufi.read())!=-1){  
45.             bufo.write(len);  
46.         }  
47.         s.shutdownOutput();  
48.         System.out.println(bufr.readLine());  
49.         s.close();  
50.         bufi.close();  
51.     }  
52. }  
53. class ServerThread implements Runnable  
54. {  
55.     //ServetSocket服务对象  
56.     private Socket s;  
57.     public ServerThread(Socket s){  
58.         this.s = s;  
59.     }  
60.     public void run(){  
61.         int count =1;  
62.         try  
63.         {  
64.             //获取客户端对象  
65.             String ip = s.getInetAddress().getHostAddress();  
66.             File file = new File("d:\\pic");  
67.             if(!file.exists())  
68.                 file.mkdir();  
69.             File dir = new File(file,ip+"("+(count)+")"+".jpg");  
70.             //创建读取流，从socket流中读取数据  
71.             BufferedInputStream bufr =  
72.                 new BufferedInputStream(s.getInputStream());  
73.             //判断文件是否存在，存在更改文件名  
74.             while(dir.exists()){  
75.                 dir = new File(file,ip+"("+(count++)+")"+".jpg");  
76.             }  
77.             //创建输出流对象，将客户端传输的数据保存到本地硬盘  
78.             BufferedOutputStream bufo =   
79.                 new BufferedOutputStream(new FileOutputStream(dir));  
80.             int len = 0;  
81.             while((len=bufr.read())!=-1){  
82.                 bufo.write(len);  
83.             }  
84.             //创建反馈信息流  
85.             PrintWriter print =  
86.                 new PrintWriter(s.getOutputStream(),true);  
87.             print.println("上传成功！！！");  
88.             bufo.close();             
89.         }  
90.         catch (Exception e)  
91.         {  
92.         }  
93.     }  
94. }  
95. class PicServer  
96. {  
97.     public static void main(String [] args) throws Exception  
98.     {  
99.         ServerSocket ss = new ServerSocket(1005);  
100.         while(true){  
101.             Socket s = ss.accept();  
102.             new Thread(new ServerThread(s)).start();  
103.         }  
104.     }  
105. }  
106. </span>  

二、客户端并发登录

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

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

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

        最多就登录三次。

[java]  view plain copy print ?

1. /* 
2. 需求：客户端并发登录 
3.  
4.         客户端通过键盘录入用户名，服务端对这个用户名进行校验。 
5.  
6.         如果该用户存在，在服务端显示xxx，已登陆；并在客户端显示xxx，欢迎光临。 
7.  
8.         如果用户不存在，在服务端显示xxx，尝试登陆；并在客户端显示xxx，该用户不存在。 
9.  
10.         最多就登录三次。 
11. */  
12. import java.io.*;  
13. import java.net.*;  
14. class  UserSocket  
15. {  
16.     public static void main(String[] args) throws Exception  
17.     {  
18.         //创建Socket服务  
19.         Socket s = new Socket("127.0.0.1",1006);  
20.         //创建读取流，从键盘读取录入数据  
21.         BufferedReader bufr =  
22.             new BufferedReader(new InputStreamReader(System.in));  
23.         //定义目的，将数据写入socket流，并传输到服务端  
24.         PrintWriter print =   
25.             new PrintWriter(new BufferedWriter(  
26.             new OutputStreamWriter(s.getOutputStream())),true);  
27.         //创建读取服务端反馈信息流  
28.         BufferedReader readSer =  
29.             new BufferedReader(new InputStreamReader(s.getInputStream()));  
30.         String data = null;  
31.         //控制用户输入次数  
32.         for(int i=0;i<3;i++){  
33.             data = bufr.readLine();  
34.             print.println(data);  
35.             //打印服务端反馈信息  
36.             String str = readSer.readLine();  
37.             System.out.println(str);  
38.             if(str.contains("欢迎"))  
39.                 break;        
40.         }  
41.         bufr.close();  
42.         s.close();  
43.     }  
44. }  
45. class User implements Runnable  
46. {  
47.     private Socket s;  
48.     public User(Socket s){  
49.         this.s = s;  
50.     }  
51.     public void run(){  
52.           
53.         try  
54.         {             
55.                 System.out.println("IP"+(s.getInetAddress().getHostAddress()));  
56.                 System.out.println("22222222222");  
57.                 //创建读取流，从socket流中读取客户端传输的数据  
58.                 BufferedReader bufr =  
59.                     new BufferedReader(new InputStreamReader(s.getInputStream()));  
60.                 //创建读取流，从本地硬盘读取用户信息  
61.                 BufferedReader bufUser =   
62.                     new BufferedReader(new FileReader("D:\\userInfo.txt"));  
63.                 //定义打印流，输出服务端反馈信息  
64.                 PrintWriter print =   
65.                     new PrintWriter(s.getOutputStream(),true);  
66.             //这个for循环很重要，没有它，数据只能传输一次  
67.             /*这里一定要放到循环中来，因为这是一个线程，如果没有循环，服务端接收完 
68.             一次客户端传输的数据后，该线程就结束了，和之前的控制台转换大写是一个道理 
69.             */  
70.             for(int i=0;i<3;i++){  
71.                 String name = bufr.readLine();  
72.                 //定义标记，用于判断用户是否存在  
73.                 boolean flag = false;             
74.                 String line = null;  
75.                 while((line=bufUser.readLine())!=null){  
76.                     if(line.equals(name)){  
77.                         flag = true;  
78.                         break;  
79.                     }             
80.                 }  
81.                 if(flag==true){  
82.                     print.println(name+"欢迎光临！");  
83.                     System.out.println(name+"已登陆");  
84.                     break;  
85.                 }  
86.                 else{  
87.                     print.println(name+"该用户不存在");  
88.                     System.out.println(name+"尝试登陆");  
89.                 }  
90.               
91.             }     
92.         }  
93.         catch (Exception e)  
94.         {  
95.         }  
96.     }  
97. }  
98. class UserServer  
99. {  
100.     public static void main(String [] args)throws Exception  
101.     {  
102.         ServerSocket ss = new ServerSocket(1006);  
103.           
104.         while(true){  
105.             Socket s = ss.accept();  
106.             System.out.println("1111111111111");  
107.             new Thread(new User(s)).start();  
108.         }  
109.     }  
110. }  

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

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

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

示例：

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

[java]  view plain copy print ?

1. <span style="font-size:14px;">/* 
2.     客户端为浏览器 
3.     向浏览器反馈信息 
4.     注意：使用浏览器作为客户端访问服务器时，客户端会给服务端发送“消息头” 
5.     只需要通过socket服务的getInputStream()方法即可获取： 
6.     如：在客户端输入http://192.168.1.254:11000/myweb/demo.html HTTP/1.1  
7.     则客户端向服务端发送的消息头为： 
8.  
9.     GET /myweb/demo.html HTTP/1.1       //这是客户端在告诉服务端要访问的资源路径 
10.     Accept: application/x-shockwave-flash, image/gif, image/x-xbitmap, image/jpeg, i 
11.     mage/pjpeg, application/vnd.ms-excel, application/vnd.ms-powerpoint, application 
12.     /msword, application/QVOD, application/QVOD,//这是在告诉服务端客户端支持的类型 
13.     Accept-Language: zh-cn  //这是在告诉服务端客户端支持的语言 
14.     Accept-Encoding: gzip, deflate  //这是在告诉服务端客户端支持的压缩格式 
15.     User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0 
16.     .50727) 
17.     Host: 192.168.1.254:11000   //这是告诉服务端客户端要访问的192.168.1.254主机的11000端口号 
18.     Connection: Keep-Alive      //这是告诉服务端要保持连接 
19. */  
20. import java.net.*;  
21. import java.io.*;  
22. class  ServerToIE  
23. {  
24.     //在客户端输入http://127.0.0.1访问  
25.     public static void main(String[] args) throws Exception  
26.     {  
27.         //创建socket服务  
28.         ServerSocket ss = new ServerSocket(10086);  
29.         //获取客户端对象  
30.         Socket s = ss.accept();  
31.         //获取客户端发送的数据（包含消息头）  
32.         InputStream in = s.getInputStream();  
33.         byte [] data = new byte[1024];  
34.         int len = in.read(data);  
35.             System.out.println(new String(data,0,len));   
36.         /*服务端反馈信息（包含应答消息头），不在浏览器上显示， 
37.         因为浏览器是应用层，被解析了，所以我们在浏览器上只能看到“哥们，收到！！”*/  
38.         PrintWriter print = new PrintWriter(s.getOutputStream(),true);  
39.         print.println("哥们，收到！！！");  
40.         s.close();  
41.     }  
42. }  
43. //向服务端z（Tomcat服务器）发送自定义消息头，并打印应答消息头  
44. class SocketToServer  
45. {  
46.     public static void main(String [] args)throws Exception  
47.     {  
48.         //创建socket服务  
49.         Socket s =  new Socket("127.0.0.1",10086);  
50.         //定义目的，将数据写入Socket流，并传输给服务端  
51.         PrintWriter print =  new PrintWriter(s.getOutputStream(),true);  
52.         print.println("GET / HTTP/1.1");     
53.         /*这里我们是直接访问10086端口，要想指定资源路径， 
54.         可以使用Tomcat服务器，把资源放到Tomcat的webapps目录下即可*/  
55.         print.println("Accept: */*");   // */*代表所支持的类型及格式  如图片，视频及其格式  
56.         print.println("Accept-Language: zh-cn");  //支持的语言  
57.         print.println("Host: 127.0.0.1:10086 ");//要访问的主机的端口  
58.         print.println("Connection: closed"); //这里一般我们自己测试是使用closed  
59.         //注意：这里一定要输出空行  
60.         print.println();  
61.         print.println();  
62.         //获取服务端反馈信息（包含应答消息头）  
63.         BufferedReader bufr =   
64.             new BufferedReader(new InputStreamReader(s.getInputStream()));  
65.         String line = null;  
66.         while((line=bufr.readLine())!=null){  
67.             System.out.println(line);  
68.         }  
69.         s.close();  
70.     }  
71. }  
72. </span>  

四、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 print ?

1. <span style="font-size:14px;">    /*  
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.                     //连接网页服务器，URLConnection是一个抽象类，里面包含getInputStream方法和getOutputStream方法  
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.     }  </span>