TCP网络编程【实例】

TCP实例一
文章来源:http://blog.csdn.net/webrobot/article/details/7425078

[java]  view plain copy print ?

1. package com.nbchina.tcp1;  
2.   
3. import java.io.IOException;  
4. import java.io.OutputStream;  
5. import java.net.Socket;  
6.   
7.   
8. public class TcpClinet {  
9.   
10.   
11.     public static void main(String[] args) throws Exception, IOException {  
12.         Socket s = new Socket("192.168.1.68",10003);  
13.           
14.         OutputStream out = s.getOutputStream();  
15.           
16.         out.write("Tcp send data...".getBytes());  
17.           
18.         s.close();  
19.     }  
20.   
21. }  
22.   
23.   
24.   
25. package com.nbchina.tcp1;  
26.   
27. import java.io.IOException;  
28. import java.io.InputStream;  
29. import java.net.ServerSocket;  
30. import java.net.Socket;  
31.   
32. //服务端、客户端通讯，服务端守候并显示客户端发来的信息  
33. public class TcpServer {  
34.   
35.   
36.     public static void main(String[] args) throws IOException {  
37.         //建立服务端socket服务，并监听一个端口  
38.         ServerSocket ss = new ServerSocket(10003);  
39.         //通过accept 方法获取连接来的客户端对象  
40.         Socket s = ss.accept();  
41.         String ip = s.getInetAddress().getHostAddress();  
42.         System.out.println(ip+"...connected");  
43.           
44.         //获取客户端发来的数据  
45.         InputStream is = s.getInputStream();  
46.           
47.         byte[] buf = new byte[1024];  
48.         int len = is.read(buf);  
49.         System.out.println(new String(buf,0,len));  
50.         s.close();//关闭客户端。服务端关的不是自己。是客户端。  
51.         ss.close();//关闭服务端  
52.     }  
53.   
54. }  

TCP实例二

[java]  view plain copy print ?

1. package com.nbchina.tcp2;  
2.   
3. import java.io.InputStream;  
4. import java.io.OutputStream;  
5. import java.net.Socket;  
6.   
7.   
8. public class TcpClinet {  
9.   
10.   
11.     public static void main(String[] args) throws Exception {  
12.         Socket s = new Socket("192.168.1.68",10008);  
13.           
14.         OutputStream out = s.getOutputStream();  
15.           
16.         out.write("Tcp send data...".getBytes());  
17.           
18.         InputStream is = s.getInputStream();  
19.           
20.         byte[] buf = new byte[1024];  
21.           
22.         int len = is.read(buf);  
23.           
24.         System.out.println(new String(buf,0,len));  
25.         s.close();  
26.     }  
27.   
28. }  
29.   
30.   
31. package com.nbchina.tcp2;  
32.   
33. import java.io.InputStream;  
34. import java.io.OutputStream;  
35. import java.net.ServerSocket;  
36. import java.net.Socket;  
37. //客户端、服务端通讯互相发送消息  
38.   
39.   
40. public class TcpServer {  
41.   
42.   
43.     public static void main(String[] args) throws Exception {  
44.         //建立服务端socket服务，并监听一个端口  
45.         ServerSocket ss = new ServerSocket(10008);  
46.         //通过accept 方法获取连接来的客户端对象  
47.         Socket s = ss.accept();  
48.         String ip = s.getInetAddress().getHostAddress();  
49.         System.out.println(ip+"...connected");  
50.           
51.         //获取客户端发来的数据  
52.         InputStream is = s.getInputStream();  
53.           
54.         byte[] buf = new byte[1024];  
55.         int len = is.read(buf);  
56.         System.out.println(new String(buf,0,len));  
57.           
58.         OutputStream out = s.getOutputStream();  
59.           
60.         out.write("收到客户端发来的信息".getBytes());  
61.         s.close();//关闭客户端。服务端关的不是自己。是客户端。  
62.         ss.close();//关闭服务端  
63.     }  
64.   
65. }  

TCP实例三

[java]  view plain copy print ?

1. package com.nbchina.tcp3;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.BufferedWriter;  
5. import java.io.InputStreamReader;  
6. import java.io.OutputStreamWriter;  
7. import java.io.PrintWriter;  
8. import java.net.Socket;  
9.   
10.   
11. public class TcpClinet {  
12.   
13.   
14.     public static void main(String[] args) throws Exception {  
15.         Socket s = new Socket("192.168.1.2",10008);  
16.         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
17.           
18.         //BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
19.           
20.         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
21.           
22.         PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
23.           
24.         String line = null;  
25.           
26.         while((line=bufr.readLine())!=null){  
27.               
28.             if("over".equals(line)){  
29.                 break;                
30.             }  
31.             out.println(line);  
32. /*          bufOut.write(line); 
33.             bufOut.newLine(); 
34.             bufOut.flush();*/  
35.               
36.             String str = bufIn.readLine();  
37.             System.out.println("server:"+str);  
38.         }  
39.         bufr.close();  
40.         s.close();  
41.     }  
42.   
43. }  
44.   
45.   
46.   
47. package com.nbchina.tcp3;  
48.   
49. import java.io.BufferedReader;  
50. import java.io.BufferedWriter;  
51. import java.io.InputStreamReader;  
52. import java.io.OutputStreamWriter;  
53. import java.io.PrintWriter;  
54. import java.net.ServerSocket;  
55. import java.net.Socket;  
56. //客户端、服务端通讯互相发送消息  
57.   
58. /* 
59.  * 要求建立一个文本转换服务端 
60.  * 客户端发给服务端文本，服务端将文本转换为大写返回给客户端。 
61.  * 而且客户端可以不断的进行文本转换，当客户端输入over时，转换结束。 
62.  * 分析： 
63.  * 客户端： 
64.  * 既然是操作设备上的数据，可以用io技术，并按照io的操作规则来思考。 
65.  * 源：键盘录入 
66.  * 目的：网络设备，网络输出流。 
67.  * 而且操作的是文本数据，可以选择字符流。 
68.  *  
69.  * 步骤 
70.  * 1、建立服务 
71.  * 2、获取键盘录入 
72.  * 3、将数据发给服务端 
73.  * 4、服务端返回大写数据 
74.  * 5、结束、关闭资源 
75.  *  
76.  * 都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。 
77.  *  
78.  */  
79.   
80. public class TcpServer {  
81.   
82.   
83.     public static void main(String[] args) throws Exception {  
84.         //建立服务端socket服务，并监听一个端口  
85.         ServerSocket ss = new ServerSocket(10008);  
86.         //通过accept 方法获取连接来的客户端对象  
87.         Socket s = ss.accept();  
88.         String ip = s.getInetAddress().getHostAddress();  
89.         System.out.println(ip+"...connected");  
90.           
91.         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
92.           
93.         //BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
94.           
95.         //既可以接受字节流又可以接受字符流  
96.         //PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
97.         PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
98.           
99.         String line = null;  
100.           
101.         while((line=bufIn.readLine())!=null){  
102.             out.println(line.toUpperCase());  
103. /*          bufOut.write(line.toUpperCase()); 
104.             bufOut.newLine(); 
105.             bufOut.flush();*/  
106.         }  
107.         s.close();//关闭客户端。服务端关的不是自己。是客户端。  
108.         ss.close();//关闭服务端  
109.     }  
110.   
111. }  

TCP实例四

[java]  view plain copy print ?

1. package com.nbchina.tcp4;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.FileReader;  
5. import java.io.InputStreamReader;  
6. import java.io.PrintWriter;  
7. import java.net.Socket;  
8.   
9. //通过tcp复制文本文件。  
10. //注意使用流结束标志。  
11. //一般使用流结束标志。也可以自定义标志。  
12.   
13. public class TcpClinet {  
14.   
15.   
16.     public static void main(String[] args) throws Exception {  
17.         Socket s = new Socket("192.168.1.2",10008);  
18.         BufferedReader bufr = new BufferedReader(new FileReader("IPDeom.java"));  
19.   
20.           
21.         PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
22. /*      DataOutputStream dos = new DataOutputStream(s.getOutputStream()); 
23.         long time = System.currentTimeMillis(); 
24.         dos.writeLong(time);*/  
25.           
26.         String line = null;  
27.           
28.         while((line=bufr.readLine())!=null){  
29.           
30.             out.println(line);  
31.   
32.         }  
33.         s.shutdownOutput();//一般使用关闭客户端输出流，相当于给流加入一个结束标记   
34.         //dos.writeLong(time);//使用时间戳作为结束标志  
35.         //out.println("over");//输出结束，供服务端判断。否则双方都在等待  
36.           
37.         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
38.           
39.         String str = bufIn.readLine();  
40.         System.out.println("server:"+str);  
41.           
42.         bufr.close();  
43.         s.close();  
44.     }  
45.   
46. }  
47.   
48.   
49. package com.nbchina.tcp4;  
50.   
51. import java.io.BufferedReader;  
52. import java.io.DataInputStream;  
53. import java.io.FileWriter;  
54. import java.io.InputStreamReader;  
55. import java.io.PrintWriter;  
56. import java.net.ServerSocket;  
57. import java.net.Socket;  
58.   
59. //(TCP复制文件)  
60. /* 
61.  *  
62.  */  
63.   
64. public class TcpServer {  
65.   
66.   
67.     public static void main(String[] args) throws Exception {  
68.         //建立服务端socket服务，并监听一个端口  
69.         ServerSocket ss = new ServerSocket(10008);  
70.         //通过accept 方法获取连接来的客户端对象  
71.         Socket s = ss.accept();  
72.         String ip = s.getInetAddress().getHostAddress();  
73.         System.out.println(ip+"...connected");  
74.           
75.         DataInputStream dis = new DataInputStream(s.getInputStream());  
76.         long l = dis.readLong();  
77.           
78.         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
79.   
80.         PrintWriter out = new PrintWriter(new FileWriter("server.txt"),true);  
81.           
82.         String line = null;  
83.           
84.         while((line=bufIn.readLine())!=null){  
85.             /*if("over".equals(line)) 
86.                 break;*/  
87.   
88.             out.println(line);  
89.         }  
90.         PrintWriter pw = new PrintWriter(s.getOutputStream(),true);  
91.         pw.println("上传成功");  
92.         out.close();  
93.         s.close();//关闭客户端。服务端关的不是自己。是客户端。  
94.         ss.close();//关闭服务端  
95.     }  
96.   
97. }  

TCP实例五

[java]  view plain copy print ?

1. package com.nbchina.tcp5;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.InputStream;  
5. import java.io.OutputStream;  
6. import java.net.Socket;  
7.   
8. //通过tcp复制图片文件。  
9.   
10. public class TcpClinet {  
11.   
12.   
13.     public static void main(String[] args) throws Exception {  
14.         Socket s = new Socket("192.168.1.2",10008);  
15.         FileInputStream fis = new FileInputStream("1.bmp");  
16.         OutputStream out = s.getOutputStream();  
17.         byte[] buf = new byte[1024];  
18.           
19.           
20.         int len = 0;  
21.           
22.         while((len=fis.read(buf))!=-1){  
23.           
24.             out.write(buf,0,len);  
25.   
26.         }  
27.         s.shutdownOutput();  
28.         InputStream in = s.getInputStream();  
29.         byte[] bufIn = new byte[1024];  
30.         int num = in.read(bufIn);  
31.         System.out.println(new String(bufIn,0,num));  
32.           
33.           
34.         fis.close();  
35.         s.close();  
36.     }  
37.   
38. }  
39.   
40.   
41. package com.nbchina.tcp5;  
42.   
43. import java.io.FileOutputStream;  
44. import java.io.InputStream;  
45. import java.io.OutputStream;  
46. import java.net.ServerSocket;  
47. import java.net.Socket;  
48.   
49.   
50. /* 
51.  * 单人上传图片 
52.  */  
53.   
54. public class TcpServer {  
55.   
56.   
57.     public static void main(String[] args) throws Exception {  
58.         //建立服务端socket服务，并监听一个端口  
59.         ServerSocket ss = new ServerSocket(10008);  
60.         //通过accept 方法获取连接来的客户端对象  
61.         Socket s = ss.accept();  
62.         String ip = s.getInetAddress().getHostAddress();  
63.         System.out.println(ip+"...connected");  
64.           
65.         InputStream in = s.getInputStream();  
66.         FileOutputStream fos = new FileOutputStream("server.bmp");  
67.           
68.         byte[] buf = new byte[1024];  
69.         int len = 0;  
70.         while((len=in.read(buf))!=-1){  
71.           
72.             fos.write(buf,0,len);  
73.   
74.         }  
75.           
76.         OutputStream out = s.getOutputStream();  
77.         out.write("上传成功".getBytes());  
78.         fos.close();  
79.         s.close();//关闭客户端。服务端关的不是自己。是客户端。  
80.         ss.close();//关闭服务端  
81.     }  
82.   
83. }  

TCP实例六

[java]  view plain copy print ?

1. package com.nbchina.tcp6;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.InputStream;  
6. import java.io.OutputStream;  
7. import java.net.Socket;  
8.   
9. //通过tcp复制图片文件。  
10.   
11. public class TcpClinet {  
12.   
13.   
14.     public static void main(String[] args) throws Exception {  
15.         if(args.length!=1){  
16.             System.out.println("请选择一个jpg格式的图片");  
17.             return;  
18.         }  
19.           
20.         File file = new File(args[0]);  
21.         if(!(file.exists()&&file.isFile())){  
22.             System.out.println("该文件有问题，不存在或者不是文件");  
23.             return;  
24.         }  
25.         if(!file.getName().endsWith(".jpg")){  
26.             System.out.println("格式错误");  
27.             return;  
28.         }  
29.               
30.         if(file.length()>1024*1024*5){  
31.             System.out.println("文件过大");  
32.             return;  
33.         }  
34.               
35.           
36.         Socket s = new Socket("192.168.1.2",10008);  
37.         FileInputStream fis = new FileInputStream(file);  
38.         OutputStream out = s.getOutputStream();  
39.         byte[] buf = new byte[1024];  
40.           
41.           
42.         int len = 0;  
43.           
44.         while((len=fis.read(buf))!=-1){  
45.           
46.             out.write(buf,0,len);  
47.   
48.         }  
49.         s.shutdownOutput();  
50.         InputStream in = s.getInputStream();  
51.         byte[] bufIn = new byte[1024];  
52.         int num = in.read(bufIn);  
53.         System.out.println(new String(bufIn,0,num));  
54.           
55.           
56.         fis.close();  
57.         s.close();  
58.     }  
59.   
60. }  
61.   
62.   
63. package com.nbchina.tcp6;  
64.   
65. import java.io.File;  
66. import java.io.FileOutputStream;  
67. import java.io.InputStream;  
68. import java.io.OutputStream;  
69. import java.net.ServerSocket;  
70. import java.net.Socket;  
71.   
72.   
73. /* 
74.  * 并发上传图片 
75.  */  
76. class PicTread implements Runnable{  
77.     private Socket s;  
78.     PicTread(Socket s){  
79.         this.s=s;  
80.     }  
81.     public void run(){  
82.         int count=1;  
83.         String ip= s.getInetAddress().getHostAddress();  
84.         try{  
85.             System.out.println(ip+"...connected");  
86.             InputStream in = s.getInputStream();  
87.             File file = new File(ip+"("+(count)+")"+".jpg");  
88.             while(file.exists()){  
89.                 file = new File(ip+"("+(count)+")"+".jpg");  
90.             }  
91.             FileOutputStream fos = new FileOutputStream(file);  
92.               
93.             byte[] buf = new byte[1024];  
94.             int len = 0;  
95.             while((len=in.read(buf))!=-1){  
96.               
97.                 fos.write(buf,0,len);  
98.   
99.             }  
100.               
101.             OutputStream out = s.getOutputStream();  
102.             out.write((ip+"上传成功").getBytes());  
103.             fos.close();  
104.             s.close();//关闭客户端。服务端关的不是自己。是客户端。         
105.         }catch(Exception e){  
106.             throw new RuntimeException(ip+"上传失败");  
107.         }  
108.     }  
109. }  
110. public class TcpServer {  
111.   
112.   
113.     public static void main(String[] args) throws Exception {  
114.         //建立服务端socket服务，并监听一个端口  
115.         ServerSocket ss = new ServerSocket(10008);  
116.         while(true){  
117.             Socket s = ss.accept();  
118.             new Thread(new PicTread(s)).start();  
119.         }  
120.           
121.   
122.         //ss.close();//关闭服务端  
123.     }  
124.   
125. }  

TCP实例七

[java]  view plain copy print ?

1. package com.nbchina.tcp7;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.InputStreamReader;  
5. import java.io.PrintWriter;  
6. import java.net.Socket;  
7.   
8. //通过tcp登录  
9.   
10. public class TcpClinet {  
11.   
12.   
13.     public static void main(String[] args) throws Exception {  
14.   
15.           
16.         Socket s = new Socket("192.168.1.2",10008);  
17.         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
18.         PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
19.         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
20.           
21.         for(int x = 0;x < 3;x++){  
22.             String line = bufr.readLine();  
23.             if(line==null)  
24.                 break;  
25.             out.println(line);  
26.             String info = bufIn.readLine();  
27.             System.out.println("info:"+info);  
28.             if(info.contains("欢迎")){  
29.                 break;  
30.             }  
31.         }  
32.   
33.         bufr.close();  
34.         s.close();  
35.     }  
36.   
37. }  
38.   
39.   
40.   
41. package com.nbchina.tcp7;  
42.   
43. import java.io.BufferedReader;  
44. import java.io.FileReader;  
45. import java.io.InputStreamReader;  
46. import java.io.PrintWriter;  
47. import java.net.ServerSocket;  
48. import java.net.Socket;  
49.   
50.   
51. /* 
52.  *  
53.  */  
54. class UserTread implements Runnable{  
55.     private Socket s;  
56.     UserTread(Socket s){  
57.         this.s=s;  
58.     }  
59.     public void run(){  
60.         String ip= s.getInetAddress().getHostAddress();  
61.         System.out.println(ip+"...connected");  
62.         try{  
63.             for(int x=0;x<3;x++){  
64.                 BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
65.                 String name = bufIn.readLine();  
66.                 if(name==null){  
67.                     break;  
68.                 }  
69.                 BufferedReader bufr = new BufferedReader(new FileReader("user.txt"));  
70.                 PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
71.                 String line = null;  
72.                   
73.                 boolean flag = false;  
74.                 while((line = bufr.readLine())!=null){  
75.                     if(line.equals(name)){  
76.                         flag = true;  
77.                         break;  
78.                     }  
79.                 }  
80.                   
81.                 if(flag){  
82.                     System.out.println(name+"已经登录");  
83.                     out.println(name+"欢迎光临");  
84.                     break;  
85.                 }else{  
86.                     System.out.println(name+"尝试登录");  
87.                     out.println(name+"不存在");  
88.                 }  
89.               
90.             }  
91.             s.close();//关闭客户端。服务端关的不是自己。是客户端。         
92.         }catch(Exception e){  
93.             throw new RuntimeException(ip+"登录失败");  
94.         }  
95.     }  
96. }  
97. public class TcpServer {  
98.   
99.   
100.     public static void main(String[] args) throws Exception {  
101.         //建立服务端socket服务，并监听一个端口  
102.         ServerSocket ss = new ServerSocket(10008);  
103.         while(true){  
104.             Socket s = ss.accept();  
105.             new Thread(new UserTread(s)).start();  
106.         }  
107.           
108.   
109.         //ss.close();//关闭服务端  
110.     }  
111.   
112. }  

TCP实例八 ---->服务消息转换

[java]  view plain copy print ?

1. package com.nbchina.tcp.client;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.DataInputStream;  
5. import java.io.DataOutputStream;  
6. import java.io.IOException;  
7. import java.io.InputStreamReader;  
8. import java.net.InetAddress;  
9. import java.net.Socket;  
10. import java.util.logging.Level;  
11. import java.util.logging.Logger;  
12.   
13. import com.nbchina.tcp.server.Server;  
14.   
15.   
16. /** 
17.  * 此类模拟客户端发出更新请求，在运行期间会要求用户输入指令码 
18.  * 举例：输入FDFCF802AAAAAAAAAAAAAAAAAAAAAAAA0000X，详细查看《端口与服务器通讯协议》 
19.  * 此类可以多次运行，从而模拟多个终端 如果输入的指令码错误，服务器将不予解析 
20.  *  
21.  */  
22. public class Client {  
23.     protected static Logger logger = Logger.getLogger(Server.class.getName());  
24.   
25.     static {  
26.         logger.setLevel(Level.ALL); // 查看所有跟踪信息  
27.     }  
28.   
29.     public void call() {  
30.         int p = 0;  
31.         DataInputStream in;  
32.         DataOutputStream out;  
33.         Socket socket = null;  
34.         try {  
35.             socket = new Socket(InetAddress.getByName(null), Server.PORT_SERVER);  
36.             /* 
37.              * 确保一个进程关闭Socket后，即使他还未释放端口，同一个主机的其他进程还可以立即重用该端口, 
38.              * 可调用socket.setReuseAddress(true)，默认false 
39.              */  
40.   
41.             socket.setReuseAddress(true);  
42.             p = socket.getLocalPort(); // 获取本地TCP端口，用于区分不同的客户端  
43.             logger.info("新建客户端连接@" + p);  
44.             in = new DataInputStream(socket.getInputStream());  
45.             out = new DataOutputStream(socket.getOutputStream());  
46.   
47.             System.out.print("请输入指令字符串（以回车键结束，以FDFCF8开头）：");  
48.             BufferedReader line = new BufferedReader(new InputStreamReader(  
49.                     System.in));  
50.             String s = line.readLine();  
51.             // 将字符串转换成字节数组  
52.             for (int ii : s2a(s)) {  
53.                 out.write(ii);  
54.             }  
55.   
56.             out.flush();  
57.             socket.shutdownOutput(); // 发送指令完毕  
58.   
59.             // 接收服务端响应  
60.             StringBuffer sb = new StringBuffer();  
61.             while (true) {  
62.                 try {  
63.                     int b = in.readUnsignedByte();  
64.                     sb.append(Integer.toHexString(b));  
65.                 } catch (Exception e) {  
66.                     break;  
67.                 }  
68.             }  
69.   
70.             sb.insert(0, "收到了服务器响应：");  
71.             System.out.println(sb.toString().toUpperCase());  
72.   
73.             in.close();  
74.             out.close();  
75.             logger.info("客户端关闭@" + p);  
76.         } catch (IOException e) {  
77.             logger.severe(e.getMessage());  
78.             e.printStackTrace();  
79.         } finally {  
80.             try {  
81.                 if (socket != null)  
82.                     socket.close();  
83.             } catch (IOException e) {  
84.                 e.printStackTrace();  
85.             }  
86.         }  
87.     }  
88.   
89.     public static void main(String[] args) {  
90.          new Client().call();  
91.   
92. //      int[] b = GportClient.s2a("20EFD23FE");  
93. //      for (int bi : b) {  
94. //          System.out.println(bi);  
95. //      }  
96.     }  
97.   
98.     static int[] s2a(String s) {  
99.         if (s == null || "".equals(s)) return new int[0];  
100.         StringBuffer sb = new StringBuffer(s);  
101.         int[] ba = new int[sb.length() / 2 + sb.length() % 2];  
102.         int l = sb.length();  
103.         for (int i = 0, c = 0; i < l; i++, c++) {  
104.             String tmp = "" + sb.charAt(i++);  
105.             if (i < l)  
106.                 tmp += sb.charAt(i);  
107.             ba[c] = Integer.parseInt(tmp, 16);  
108.         }  
109.         return ba;  
110.     }  
111. }  
112.   
113.   
114.   
115. package com.nbchina.tcp.server;  
116.   
117. import java.io.IOException;  
118. import java.net.InetAddress;  
119. import java.net.ServerSocket;  
120. import java.net.Socket;  
121. import java.util.logging.Level;  
122. import java.util.logging.Logger;  
123.   
124. import com.nbchina.tcp.msg.DisconnectMessage;  
125. import com.nbchina.tcp.msg.Message;  
126.   
127. /** 
128.  * 守护的通信服务器，可以启动和关闭<br> 
129.  * 启动后，服务器运行一个守护线程负责接收终端更新请求，并分配给解析器解析编码 提供通用的socket发送和接收功能 
130.  *  
131.  */  
132. public class Server extends ServerSocket {  
133.     protected static Logger logger = Logger.getLogger(Server.class.getName());  
134.   
135.     static {  
136.         logger.setLevel(Level.ALL);       // 查看所有跟踪信息  
137.     }  
138.       
139.     public static final int PORT_SERVER = 10000;  
140.       
141.     public static final int MSG_MAX_LENGTH = 1024;  
142.       
143.       
144.     private static Server server;  
145.   
146.     public static Server newInstant() {  
147.         if (server == null) {  
148.             try {  
149.                 server = new Server();  
150.             } catch (IOException e) {  
151.                 // TODO Auto-generated catch block  
152.                 e.printStackTrace();  
153.             }  
154.         }  
155.         return server;  
156.     }  
157.       
158.     private Server() throws IOException {  
159.         super(PORT_SERVER);  
160.     }  
161.   
162.     public void start() {  
163.         try {  
164.             while (true) {  
165.                 Socket socket = this.accept();  
166.                 logger.info("建立新会话");  
167.                 //new Instant(socket).start();  Instant extends Thread修改为 Instant implements Runnable  
168.                 new Thread(new Instant(socket)).start();  
169.             }  
170.         } catch (Exception e) {  
171.             logger.severe("服务器启动或接收数据失败：" + e.getMessage());  
172.         } finally {  
173.             try {  
174.                 logger.info("关闭服务器");  
175.                 super.close();  
176.             } catch (IOException e) {  
177.                 logger.severe("服务器关闭失败：" + e.getMessage());  
178.             }  
179.         }  
180.     }  
181.   
182.     /** 
183.      * 一个服务器实例，根据目前设计，一个终端的一次会话对应一个实例 
184.      * 单例模式，懒汉 
185.      */  
186.     public static class Instant implements Runnable {  
187.         private Socket socket;  
188.   
189.         public Instant(Socket socket) {  
190.             this.socket = socket;  
191.         }  
192.   
193.         public Socket getSocket() {  
194.             return socket;  
195.         }  
196.           
197.         public void run() {  
198.             logger.info("成功创建一个连接，等待客户端数据");  
199.               
200.             Message reponse;  
201.             try {  
202.                 reponse = new Receiver(socket).process();  
203.                 logger.info("数据处理完成，发送响应");  
204.                   
205.                 Sender sender = new Sender(socket);  
206.                 if (reponse != null) {  
207.                     sender.send(reponse);  
208.                 }  
209.                   
210.                 // 总在最后发送关闭消息  
211.                 Message close = new DisconnectMessage();  
212.                 sender.send(close);  
213.                   
214.                 logger.info("连接处理完成并关闭");  
215.             } catch (Exception e) {  
216.                 InetAddress ad = socket.getInetAddress();  
217.                 logger.warning("消息处理发生错误:" + e.getMessage() + "@" + ad.getCanonicalHostName());  
218.             } finally {  
219.                 try {  
220.                     socket.close();  
221.                 } catch (IOException e) {  
222.                     e.printStackTrace();  
223.                 }  
224.             }  
225.         }  
226.     }  
227.       
228.     public static void main(String[] args) {  
229.         logger.info("开始启动服务器");  
230.         Server.newInstant().start();  
231.     }  
232. }  
233.   
234.   
235.   
236. package com.nbchina.tcp.server;  
237. import java.net.Socket;  
238. import java.util.logging.Logger;  
239.   
240. import com.nbchina.tcp.dao.StubDao;  
241. import com.nbchina.tcp.msg.Message;  
242. import com.nbchina.tcp.msg.ResponseMessage;  
243. import com.nbchina.tcp.msg.UpdateMessage;  
244.   
245.   
246. /** 
247.  * 接收并解析编码 
248.  *  
249.  */  
250. public class Receiver {  
251.     protected static Logger logger = Logger.getLogger(Receiver.class.getName());  
252.   
253.     private Socket socket;  
254.   
255.     private StubDao dao;  
256.   
257.     public Receiver(Socket socket) {  
258.         this.socket = socket;  
259.   
260.         this.dao = new StubDao();  
261.     }  
262.   
263.     public Message process() throws Exception {  
264.         UpdateMessage request = new UpdateMessage(socket.getInputStream());  
265.   
266.         // 判断是否是处理过的终端  
267.         String id = request.getId();  
268.         if (!dao.hasRegister(id)) {  
269.             // 未处理过的，先注册（注册完以后，也应该查询是否有更新，可能是服务端已经录入了终端的注册信息）  
270.             dao.register(id);  
271.         }  
272.   
273.         Message reponse = null;  
274.         if (dao.isUpdated(id)) {  
275.             // 是处理过的，查询更新信息  
276.             reponse = new ResponseMessage(dao.fillMessageDetail(id));  
277.         }  
278.   
279.         return reponse;  
280.     }  
281. }  
282.   
283.   
284.   
285. package com.nbchina.tcp.server;  
286.   
287. import java.io.DataOutputStream;  
288. import java.net.Socket;  
289. import java.util.logging.Logger;  
290.   
291. import com.nbchina.tcp.msg.Message;  
292.   
293. /** 
294.  * 负责发送消息 
295.  */  
296. public class Sender {  
297.     protected static Logger logger = Logger.getLogger(Sender.class.getName());  
298.   
299.     private Socket socket;  
300.   
301.     public Sender(Socket socket) {  
302.         this.socket = socket;  
303.     }  
304.   
305.     public void send(Message msg) throws Exception {  
306.         DataOutputStream dos = new DataOutputStream(socket.getOutputStream());  
307.         int[] data = msg.getData();  
308.         for (int d : data) {  
309.             dos.write(d);  
310.         }  
311.   
312.         dos.flush();  
313.     }  
314. }  
315.   
316. .....还有其他一些类  

网络获取图片、html

[java]  view plain copy print ?

1. public class HtmlRequest {  
2.     public static void main(String[] args) throws Exception {  
3.         URL url = new URL("http://www.sohu.com/");  
4.         HttpURLConnection conn = (HttpURLConnection)url.openConnection();  
5.         conn.setRequestMethod("GET");  
6.         conn.setConnectTimeout(5 * 1000);  
7.         InputStream inStream = conn.getInputStream();//通过输入流获取html数据  
8.         byte[] data = readInputStream(inStream);//得到html的二进制数据  
9.         String html = new String(data,"utf-8");  
10.           
11.         System.out.println(html);  
12.           
13. /*      File imageFile = new File("nbchina.htm"); 
14.         FileOutputStream outStream = new FileOutputStream(imageFile); 
15.         outStream.write(data); 
16.         outStream.close();*/  
17.           
18.     }  
19.   
20.     public static byte[] readInputStream(InputStream inStream) throws Exception{  
21.         ByteArrayOutputStream outStream = new ByteArrayOutputStream();  
22.         byte[] buffer = new byte[1024];  
23.         int len = 0;  
24.         while( (len=inStream.read(buffer)) != -1 ){  
25.             outStream.write(buffer, 0, len);  
26.         }  
27.         inStream.close();  
28.         return outStream.toByteArray();  
29.     }  
30. }  
31.   
32.   
33.   
34. public class ImageRequest {  
35.     public static void main(String[] args) throws Exception {  
36.         URL url = new URL("http://img04.taobaocdn.com/bao/uploaded/i4/T1hTSvXihAXXbeLMw1_041248.jpg_b.jpg");  
37.         HttpURLConnection conn = (HttpURLConnection)url.openConnection();  
38.         conn.setRequestMethod("GET");  
39.         conn.setConnectTimeout(5 * 1000);  
40.         InputStream inStream = conn.getInputStream();//通过输入流获取图片数据  
41.         byte[] data = readInputStream(inStream);//得到图片的二进制数据  
42.         File imageFile = new File("nbchina.jpg");  
43.         FileOutputStream outStream = new FileOutputStream(imageFile);  
44.         outStream.write(data);  
45.         outStream.close();  
46.     }  
47.   
48.     public static byte[] readInputStream(InputStream inStream) throws Exception{  
49.         ByteArrayOutputStream outStream = new ByteArrayOutputStream();  
50.         byte[] buffer = new byte[1024];  
51.         int len = 0;  
52.         while( (len=inStream.read(buffer)) != -1 ){  
53.             outStream.write(buffer, 0, len);  
54.         }  
55.         inStream.close();  
56.         return outStream.toByteArray();  
57.     }  
58. }  

多线程下载

[java]  view plain copy print ?

1. public class MulThreadDownload {  
2.   
3.     public static void main(String[] args) {  
4.         String path = "http://dl_dir.qq.com/qqfile/qq/QQ2011/QQ2011.exe";  
5.         try {  
6.             new MulThreadDownload().download(path, 5);  
7.         } catch (Exception e) {  
8.             e.printStackTrace();  
9.         }  
10.     }  
11.     /** 
12.      * 从路径中获取文件名称 
13.      * @param path 下载路径 
14.      * @return 
15.      */  
16.     public static String getFilename(String path){  
17.         return path.substring(path.lastIndexOf('/')+1);  
18.     }  
19.     /** 
20.      * 下载文件 
21.      * @param path 下载路径 
22.      * @param threadsize 线程数 
23.      */  
24.     public void download(String path, int threadsize) throws Exception{  
25.         URL url = new URL(path);  
26.         HttpURLConnection conn = (HttpURLConnection)url.openConnection();  
27.         conn.setRequestMethod("GET");  
28.         conn.setConnectTimeout(5 * 1000);  
29.         int filelength = conn.getContentLength();//获取要下载的文件的长度  
30.         String filename = getFilename(path);//从路径中获取文件名称  
31.         File saveFile = new File(filename);  
32.         RandomAccessFile accessFile = new RandomAccessFile(saveFile, "rwd");  
33.         accessFile.setLength(filelength);//设置本地文件的长度和下载文件相同  
34.         accessFile.close();  
35.         //计算每条线程下载的数据长度  
36.         int block = filelength%threadsize==0? filelength/threadsize : filelength/threadsize+1;  
37.         for(int threadid=0 ; threadid < threadsize ; threadid++){  
38.             new DownloadThread(url, saveFile, block, threadid).start();  
39.         }  
40.     }  
41.       
42.     private final class DownloadThread extends Thread{  
43.         private URL url;  
44.         private File saveFile;  
45.         private int block;//每条线程下载的数据长度  
46.         private int threadid;//线程id  
47.   
48.         public DownloadThread(URL url, File saveFile, int block, int threadid) {  
49.             this.url = url;  
50.             this.saveFile = saveFile;  
51.             this.block = block;  
52.             this.threadid = threadid;  
53.         }  
54.   
55.         @Override  
56.         public void run() {  
57.             //计算开始位置公式：线程id*每条线程下载的数据长度= ？  
58.             //计算结束位置公式：（线程id +1）*每条线程下载的数据长度-1 =?  
59.             int startposition = threadid * block;  
60.             int endposition = (threadid + 1 ) * block - 1;  
61.             try {  
62.                 RandomAccessFile accessFile = new RandomAccessFile(saveFile, "rwd");  
63.                 accessFile.seek(startposition);//设置从什么位置开始写入数据  
64.                 HttpURLConnection conn = (HttpURLConnection)url.openConnection();  
65.                 conn.setRequestMethod("GET");  
66.                 conn.setConnectTimeout(5 * 1000);  
67.                 conn.setRequestProperty("Range", "bytes="+ startposition+ "-"+ endposition);  
68.                 InputStream inStream = conn.getInputStream();  
69.                 byte[] buffer = new byte[1024];  
70.                 int len = 0;  
71.                 while( (len=inStream.read(buffer)) != -1 ){  
72.                     accessFile.write(buffer, 0, len);  
73.                     System.out.println("线程id:"+ threadid+ "下载["+len+"]");  
74.                 }  
75.                 inStream.close();  
76.                 accessFile.close();  
77.                 System.out.println("线程id:"+ threadid+ "下载完成");  
78.             } catch (Exception e) {  
79.                 e.printStackTrace();  
80.             }  
81.         }         
82.     }  
83.   
84. }