`

TCP网络编程【实例】

 
阅读更多

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

[java]view plaincopyprint?
 
  1. packagecom.nbchina.tcp1;
  3. importjava.io.IOException;
  4. importjava.io.OutputStream;
  5. importjava.net.Socket;
  8. publicclassTcpClinet{
  11. publicstaticvoidmain(String[]args)throwsException,IOException{
  12. Sockets=newSocket("192.168.1.68",10003);
  14. OutputStreamout=s.getOutputStream();
  16. out.write("Tcpsenddata...".getBytes());
  18. s.close();
  19. }
  21. }
  25. packagecom.nbchina.tcp1;
  27. importjava.io.IOException;
  28. importjava.io.InputStream;
  29. importjava.net.ServerSocket;
  30. importjava.net.Socket;
  32. //服务端、客户端通讯，服务端守候并显示客户端发来的信息
  33. publicclassTcpServer{
  36. publicstaticvoidmain(String[]args)throwsIOException{
  37. //建立服务端socket服务，并监听一个端口
  38. ServerSocketss=newServerSocket(10003);
  39. //通过accept方法获取连接来的客户端对象
  40. Sockets=ss.accept();
  41. Stringip=s.getInetAddress().getHostAddress();
  42. System.out.println(ip+"...connected");
  44. //获取客户端发来的数据
  45. InputStreamis=s.getInputStream();
  47. byte[]buf=newbyte[1024];
  48. intlen=is.read(buf);
  49. System.out.println(newString(buf,0,len));
  50. s.close();//关闭客户端。服务端关的不是自己。是客户端。
  51. ss.close();//关闭服务端
  52. }
  54. }


TCP实例二

[java]view plaincopyprint?
 
  1. packagecom.nbchina.tcp2;
  3. importjava.io.InputStream;
  4. importjava.io.OutputStream;
  5. importjava.net.Socket;
  8. publicclassTcpClinet{
  11. publicstaticvoidmain(String[]args)throwsException{
  12. Sockets=newSocket("192.168.1.68",10008);
  14. OutputStreamout=s.getOutputStream();
  16. out.write("Tcpsenddata...".getBytes());
  18. InputStreamis=s.getInputStream();
  20. byte[]buf=newbyte[1024];
  22. intlen=is.read(buf);
  24. System.out.println(newString(buf,0,len));
  25. s.close();
  26. }
  28. }
  31. packagecom.nbchina.tcp2;
  33. importjava.io.InputStream;
  34. importjava.io.OutputStream;
  35. importjava.net.ServerSocket;
  36. importjava.net.Socket;
  37. //客户端、服务端通讯互相发送消息
  40. publicclassTcpServer{
  43. publicstaticvoidmain(String[]args)throwsException{
  44. //建立服务端socket服务，并监听一个端口
  45. ServerSocketss=newServerSocket(10008);
  46. //通过accept方法获取连接来的客户端对象
  47. Sockets=ss.accept();
  48. Stringip=s.getInetAddress().getHostAddress();
  49. System.out.println(ip+"...connected");
  51. //获取客户端发来的数据
  52. InputStreamis=s.getInputStream();
  54. byte[]buf=newbyte[1024];
  55. intlen=is.read(buf);
  56. System.out.println(newString(buf,0,len));
  58. OutputStreamout=s.getOutputStream();
  60. out.write("收到客户端发来的信息".getBytes());
  61. s.close();//关闭客户端。服务端关的不是自己。是客户端。
  62. ss.close();//关闭服务端
  63. }
  65. }


TCP实例三

[java]view plaincopyprint?
 
  1. packagecom.nbchina.tcp3;
  3. importjava.io.BufferedReader;
  4. importjava.io.BufferedWriter;
  5. importjava.io.InputStreamReader;
  6. importjava.io.OutputStreamWriter;
  7. importjava.io.PrintWriter;
  8. importjava.net.Socket;
  11. publicclassTcpClinet{
  14. publicstaticvoidmain(String[]args)throwsException{
  15. Sockets=newSocket("192.168.1.2",10008);
  16. BufferedReaderbufr=newBufferedReader(newInputStreamReader(System.in));
  18. //BufferedWriterbufOut=newBufferedWriter(newOutputStreamWriter(s.getOutputStream()));
  20. BufferedReaderbufIn=newBufferedReader(newInputStreamReader(s.getInputStream()));
  22. PrintWriterout=newPrintWriter(s.getOutputStream(),true);
  24. Stringline=null;
  26. while((line=bufr.readLine())!=null){
  28. if("over".equals(line)){
  29. break;
  30. }
  31. out.println(line);
  32. /*bufOut.write(line);
  33. bufOut.newLine();
  34. bufOut.flush();*/
  36. Stringstr=bufIn.readLine();
  37. System.out.println("server:"+str);
  38. }
  39. bufr.close();
  40. s.close();
  41. }
  43. }
  47. packagecom.nbchina.tcp3;
  49. importjava.io.BufferedReader;
  50. importjava.io.BufferedWriter;
  51. importjava.io.InputStreamReader;
  52. importjava.io.OutputStreamWriter;
  53. importjava.io.PrintWriter;
  54. importjava.net.ServerSocket;
  55. importjava.net.Socket;
  56. //客户端、服务端通讯互相发送消息
  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. */
  80. publicclassTcpServer{
  83. publicstaticvoidmain(String[]args)throwsException{
  84. //建立服务端socket服务，并监听一个端口
  85. ServerSocketss=newServerSocket(10008);
  86. //通过accept方法获取连接来的客户端对象
  87. Sockets=ss.accept();
  88. Stringip=s.getInetAddress().getHostAddress();
  89. System.out.println(ip+"...connected");
  91. BufferedReaderbufIn=newBufferedReader(newInputStreamReader(s.getInputStream()));
  93. //BufferedWriterbufOut=newBufferedWriter(newOutputStreamWriter(s.getOutputStream()));
  95. //既可以接受字节流又可以接受字符流
  96. //PrintWriterout=newPrintWriter(s.getOutputStream(),true);
  97. PrintWriterout=newPrintWriter(s.getOutputStream(),true);
  99. Stringline=null;
  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. }
  111. }



TCP实例四

[java]view plaincopyprint?
 
  1. packagecom.nbchina.tcp4;
  3. importjava.io.BufferedReader;
  4. importjava.io.FileReader;
  5. importjava.io.InputStreamReader;
  6. importjava.io.PrintWriter;
  7. importjava.net.Socket;
  9. //通过tcp复制文本文件。
  10. //注意使用流结束标志。
  11. //一般使用流结束标志。也可以自定义标志。
  13. publicclassTcpClinet{
  16. publicstaticvoidmain(String[]args)throwsException{
  17. Sockets=newSocket("192.168.1.2",10008);
  18. BufferedReaderbufr=newBufferedReader(newFileReader("IPDeom.java"));
  21. PrintWriterout=newPrintWriter(s.getOutputStream(),true);
  22. /*DataOutputStreamdos=newDataOutputStream(s.getOutputStream());
  23. longtime=System.currentTimeMillis();
  24. dos.writeLong(time);*/
  26. Stringline=null;
  28. while((line=bufr.readLine())!=null){
  30. out.println(line);
  32. }
  33. s.shutdownOutput();//一般使用关闭客户端输出流，相当于给流加入一个结束标记
  34. //dos.writeLong(time);//使用时间戳作为结束标志
  35. //out.println("over");//输出结束，供服务端判断。否则双方都在等待
  37. BufferedReaderbufIn=newBufferedReader(newInputStreamReader(s.getInputStream()));
  39. Stringstr=bufIn.readLine();
  40. System.out.println("server:"+str);
  42. bufr.close();
  43. s.close();
  44. }
  46. }
  49. packagecom.nbchina.tcp4;
  51. importjava.io.BufferedReader;
  52. importjava.io.DataInputStream;
  53. importjava.io.FileWriter;
  54. importjava.io.InputStreamReader;
  55. importjava.io.PrintWriter;
  56. importjava.net.ServerSocket;
  57. importjava.net.Socket;
  59. //(TCP复制文件)
  60. /*
  61. *
  62. */
  64. publicclassTcpServer{
  67. publicstaticvoidmain(String[]args)throwsException{
  68. //建立服务端socket服务，并监听一个端口
  69. ServerSocketss=newServerSocket(10008);
  70. //通过accept方法获取连接来的客户端对象
  71. Sockets=ss.accept();
  72. Stringip=s.getInetAddress().getHostAddress();
  73. System.out.println(ip+"...connected");
  75. DataInputStreamdis=newDataInputStream(s.getInputStream());
  76. longl=dis.readLong();
  78. BufferedReaderbufIn=newBufferedReader(newInputStreamReader(s.getInputStream()));
  80. PrintWriterout=newPrintWriter(newFileWriter("server.txt"),true);
  82. Stringline=null;
  84. while((line=bufIn.readLine())!=null){
  85. /*if("over".equals(line))
  86. break;*/
  88. out.println(line);
  89. }
  90. PrintWriterpw=newPrintWriter(s.getOutputStream(),true);
  91. pw.println("上传成功");
  92. out.close();
  93. s.close();//关闭客户端。服务端关的不是自己。是客户端。
  94. ss.close();//关闭服务端
  95. }
  97. }



TCP实例五

[java]view plaincopyprint?
 
  1. packagecom.nbchina.tcp5;
  3. importjava.io.FileInputStream;
  4. importjava.io.InputStream;
  5. importjava.io.OutputStream;
  6. importjava.net.Socket;
  8. //通过tcp复制图片文件。
  10. publicclassTcpClinet{
  13. publicstaticvoidmain(String[]args)throwsException{
  14. Sockets=newSocket("192.168.1.2",10008);
  15. FileInputStreamfis=newFileInputStream("1.bmp");
  16. OutputStreamout=s.getOutputStream();
  17. byte[]buf=newbyte[1024];
  20. intlen=0;
  22. while((len=fis.read(buf))!=-1){
  24. out.write(buf,0,len);
  26. }
  27. s.shutdownOutput();
  28. InputStreamin=s.getInputStream();
  29. byte[]bufIn=newbyte[1024];
  30. intnum=in.read(bufIn);
  31. System.out.println(newString(bufIn,0,num));
  34. fis.close();
  35. s.close();
  36. }
  38. }
  41. packagecom.nbchina.tcp5;
  43. importjava.io.FileOutputStream;
  44. importjava.io.InputStream;
  45. importjava.io.OutputStream;
  46. importjava.net.ServerSocket;
  47. importjava.net.Socket;
  50. /*
  51. *单人上传图片
  52. */
  54. publicclassTcpServer{
  57. publicstaticvoidmain(String[]args)throwsException{
  58. //建立服务端socket服务，并监听一个端口
  59. ServerSocketss=newServerSocket(10008);
  60. //通过accept方法获取连接来的客户端对象
  61. Sockets=ss.accept();
  62. Stringip=s.getInetAddress().getHostAddress();
  63. System.out.println(ip+"...connected");
  65. InputStreamin=s.getInputStream();
  66. FileOutputStreamfos=newFileOutputStream("server.bmp");
  68. byte[]buf=newbyte[1024];
  69. intlen=0;
  70. while((len=in.read(buf))!=-1){
  72. fos.write(buf,0,len);
  74. }
  76. OutputStreamout=s.getOutputStream();
  77. out.write("上传成功".getBytes());
  78. fos.close();
  79. s.close();//关闭客户端。服务端关的不是自己。是客户端。
  80. ss.close();//关闭服务端
  81. }
  83. }


TCP实例六

[java]view plaincopyprint?
 
  1. packagecom.nbchina.tcp6;
  3. importjava.io.File;
  4. importjava.io.FileInputStream;
  5. importjava.io.InputStream;
  6. importjava.io.OutputStream;
  7. importjava.net.Socket;
  9. //通过tcp复制图片文件。
  11. publicclassTcpClinet{
  14. publicstaticvoidmain(String[]args)throwsException{
  15. if(args.length!=1){
  16. System.out.println("请选择一个jpg格式的图片");
  17. return;
  18. }
  20. Filefile=newFile(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. }
  30. if(file.length()>1024*1024*5){
  31. System.out.println("文件过大");
  32. return;
  33. }
  36. Sockets=newSocket("192.168.1.2",10008);
  37. FileInputStreamfis=newFileInputStream(file);
  38. OutputStreamout=s.getOutputStream();
  39. byte[]buf=newbyte[1024];
  42. intlen=0;
  44. while((len=fis.read(buf))!=-1){
  46. out.write(buf,0,len);
  48. }
  49. s.shutdownOutput();
  50. InputStreamin=s.getInputStream();
  51. byte[]bufIn=newbyte[1024];
  52. intnum=in.read(bufIn);
  53. System.out.println(newString(bufIn,0,num));
  56. fis.close();
  57. s.close();
  58. }
  60. }
  63. packagecom.nbchina.tcp6;
  65. importjava.io.File;
  66. importjava.io.FileOutputStream;
  67. importjava.io.InputStream;
  68. importjava.io.OutputStream;
  69. importjava.net.ServerSocket;
  70. importjava.net.Socket;
  73. /*
  74. *并发上传图片
  75. */
  76. classPicTreadimplementsRunnable{
  77. privateSockets;
  78. PicTread(Sockets){
  79. this.s=s;
  80. }
  81. publicvoidrun(){
  82. intcount=1;
  83. Stringip=s.getInetAddress().getHostAddress();
  84. try{
  85. System.out.println(ip+"...connected");
  86. InputStreamin=s.getInputStream();
  87. Filefile=newFile(ip+"("+(count)+")"+".jpg");
  88. while(file.exists()){
  89. file=newFile(ip+"("+(count)+")"+".jpg");
  90. }
  91. FileOutputStreamfos=newFileOutputStream(file);
  93. byte[]buf=newbyte[1024];
  94. intlen=0;
  95. while((len=in.read(buf))!=-1){
  97. fos.write(buf,0,len);
  99. }
  101. OutputStreamout=s.getOutputStream();
  102. out.write((ip+"上传成功").getBytes());
  103. fos.close();
  104. s.close();//关闭客户端。服务端关的不是自己。是客户端。
  105. }catch(Exceptione){
  106. thrownewRuntimeException(ip+"上传失败");
  107. }
  108. }
  109. }
  110. publicclassTcpServer{
  113. publicstaticvoidmain(String[]args)throwsException{
  114. //建立服务端socket服务，并监听一个端口
  115. ServerSocketss=newServerSocket(10008);
  116. while(true){
  117. Sockets=ss.accept();
  118. newThread(newPicTread(s)).start();
  119. }
  122. //ss.close();//关闭服务端
  123. }
  125. }


TCP实例七

[java]view plaincopyprint?
 
  1. packagecom.nbchina.tcp7;
  3. importjava.io.BufferedReader;
  4. importjava.io.InputStreamReader;
  5. importjava.io.PrintWriter;
  6. importjava.net.Socket;
  8. //通过tcp登录
  10. publicclassTcpClinet{
  13. publicstaticvoidmain(String[]args)throwsException{
  16. Sockets=newSocket("192.168.1.2",10008);
  17. BufferedReaderbufr=newBufferedReader(newInputStreamReader(System.in));
  18. PrintWriterout=newPrintWriter(s.getOutputStream(),true);
  19. BufferedReaderbufIn=newBufferedReader(newInputStreamReader(s.getInputStream()));
  21. for(intx=0;x<3;x++){
  22. Stringline=bufr.readLine();
  23. if(line==null)
  24. break;
  25. out.println(line);
  26. Stringinfo=bufIn.readLine();
  27. System.out.println("info:"+info);
  28. if(info.contains("欢迎")){
  29. break;
  30. }
  31. }
  33. bufr.close();
  34. s.close();
  35. }
  37. }
  41. packagecom.nbchina.tcp7;
  43. importjava.io.BufferedReader;
  44. importjava.io.FileReader;
  45. importjava.io.InputStreamReader;
  46. importjava.io.PrintWriter;
  47. importjava.net.ServerSocket;
  48. importjava.net.Socket;
  51. /*
  52. *
  53. */
  54. classUserTreadimplementsRunnable{
  55. privateSockets;
  56. UserTread(Sockets){
  57. this.s=s;
  58. }
  59. publicvoidrun(){
  60. Stringip=s.getInetAddress().getHostAddress();
  61. System.out.println(ip+"...connected");
  62. try{
  63. for(intx=0;x<3;x++){
  64. BufferedReaderbufIn=newBufferedReader(newInputStreamReader(s.getInputStream()));
  65. Stringname=bufIn.readLine();
  66. if(name==null){
  67. break;
  68. }
  69. BufferedReaderbufr=newBufferedReader(newFileReader("user.txt"));
  70. PrintWriterout=newPrintWriter(s.getOutputStream(),true);
  71. Stringline=null;
  73. booleanflag=false;
  74. while((line=bufr.readLine())!=null){
  75. if(line.equals(name)){
  76. flag=true;
  77. break;
  78. }
  79. }
  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. }
  90. }
  91. s.close();//关闭客户端。服务端关的不是自己。是客户端。
  92. }catch(Exceptione){
  93. thrownewRuntimeException(ip+"登录失败");
  94. }
  95. }
  96. }
  97. publicclassTcpServer{
  100. publicstaticvoidmain(String[]args)throwsException{
  101. //建立服务端socket服务，并监听一个端口
  102. ServerSocketss=newServerSocket(10008);
  103. while(true){
  104. Sockets=ss.accept();
  105. newThread(newUserTread(s)).start();
  106. }
  109. //ss.close();//关闭服务端
  110. }
  112. }


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

[java]view plaincopyprint?
 
  1. packagecom.nbchina.tcp.client;
  3. importjava.io.BufferedReader;
  4. importjava.io.DataInputStream;
  5. importjava.io.DataOutputStream;
  6. importjava.io.IOException;
  7. importjava.io.InputStreamReader;
  8. importjava.net.InetAddress;
  9. importjava.net.Socket;
  10. importjava.util.logging.Level;
  11. importjava.util.logging.Logger;
  13. importcom.nbchina.tcp.server.Server;
  16. /**
  17. *此类模拟客户端发出更新请求，在运行期间会要求用户输入指令码
  18. *举例：输入FDFCF802AAAAAAAAAAAAAAAAAAAAAAAA0000X，详细查看《端口与服务器通讯协议》
  19. *此类可以多次运行，从而模拟多个终端如果输入的指令码错误，服务器将不予解析
  20. *
  21. */
  22. publicclassClient{
  23. protectedstaticLoggerlogger=Logger.getLogger(Server.class.getName());
  25. static{
  26. logger.setLevel(Level.ALL);//查看所有跟踪信息
  27. }
  29. publicvoidcall(){
  30. intp=0;
  31. DataInputStreamin;
  32. DataOutputStreamout;
  33. Socketsocket=null;
  34. try{
  35. socket=newSocket(InetAddress.getByName(null),Server.PORT_SERVER);
  36. /*
  37. *确保一个进程关闭Socket后，即使他还未释放端口，同一个主机的其他进程还可以立即重用该端口,
  38. *可调用socket.setReuseAddress(true)，默认false
  39. */
  41. socket.setReuseAddress(true);
  42. p=socket.getLocalPort();//获取本地TCP端口，用于区分不同的客户端
  43. logger.info("新建客户端连接@"+p);
  44. in=newDataInputStream(socket.getInputStream());
  45. out=newDataOutputStream(socket.getOutputStream());
  47. System.out.print("请输入指令字符串（以回车键结束，以FDFCF8开头）：");
  48. BufferedReaderline=newBufferedReader(newInputStreamReader(
  49. System.in));
  50. Strings=line.readLine();
  51. //将字符串转换成字节数组
  52. for(intii:s2a(s)){
  53. out.write(ii);
  54. }
  56. out.flush();
  57. socket.shutdownOutput();//发送指令完毕
  59. //接收服务端响应
  60. StringBuffersb=newStringBuffer();
  61. while(true){
  62. try{
  63. intb=in.readUnsignedByte();
  64. sb.append(Integer.toHexString(b));
  65. }catch(Exceptione){
  66. break;
  67. }
  68. }
  70. sb.insert(0,"收到了服务器响应：");
  71. System.out.println(sb.toString().toUpperCase());
  73. in.close();
  74. out.close();
  75. logger.info("客户端关闭@"+p);
  76. }catch(IOExceptione){
  77. logger.severe(e.getMessage());
  78. e.printStackTrace();
  79. }finally{
  80. try{
  81. if(socket!=null)
  82. socket.close();
  83. }catch(IOExceptione){
  84. e.printStackTrace();
  85. }
  86. }
  87. }
  89. publicstaticvoidmain(String[]args){
  90. newClient().call();
  92. //int[]b=GportClient.s2a("20EFD23FE");
  93. //for(intbi:b){
  94. //System.out.println(bi);
  95. //}
  96. }
  98. staticint[]s2a(Strings){
  99. if(s==null||"".equals(s))returnnewint[0];
  100. StringBuffersb=newStringBuffer(s);
  101. int[]ba=newint[sb.length()/2+sb.length()%2];
  102. intl=sb.length();
  103. for(inti=0,c=0;i<l;i++,c++){
  104. Stringtmp=""+sb.charAt(i++);
  105. if(i<l)
  106. tmp+=sb.charAt(i);
  107. ba[c]=Integer.parseInt(tmp,16);
  108. }
  109. returnba;
  110. }
  111. }
  115. packagecom.nbchina.tcp.server;
  117. importjava.io.IOException;
  118. importjava.net.InetAddress;
  119. importjava.net.ServerSocket;
  120. importjava.net.Socket;
  121. importjava.util.logging.Level;
  122. importjava.util.logging.Logger;
  124. importcom.nbchina.tcp.msg.DisconnectMessage;
  125. importcom.nbchina.tcp.msg.Message;
  127. /**
  128. *守护的通信服务器，可以启动和关闭<br>
  129. *启动后，服务器运行一个守护线程负责接收终端更新请求，并分配给解析器解析编码提供通用的socket发送和接收功能
  130. *
  131. */
  132. publicclassServerextendsServerSocket{
  133. protectedstaticLoggerlogger=Logger.getLogger(Server.class.getName());
  135. static{
  136. logger.setLevel(Level.ALL);//查看所有跟踪信息
  137. }
  139. publicstaticfinalintPORT_SERVER=10000;
  141. publicstaticfinalintMSG_MAX_LENGTH=1024;
  144. privatestaticServerserver;
  146. publicstaticServernewInstant(){
  147. if(server==null){
  148. try{
  149. server=newServer();
  150. }catch(IOExceptione){
  151. //TODOAuto-generatedcatchblock
  152. e.printStackTrace();
  153. }
  154. }
  155. returnserver;
  156. }
  158. privateServer()throwsIOException{
  159. super(PORT_SERVER);
  160. }
  162. publicvoidstart(){
  163. try{
  164. while(true){
  165. Socketsocket=this.accept();
  166. logger.info("建立新会话");
  167. //newInstant(socket).start();InstantextendsThread修改为InstantimplementsRunnable
  168. newThread(newInstant(socket)).start();
  169. }
  170. }catch(Exceptione){
  171. logger.severe("服务器启动或接收数据失败："+e.getMessage());
  172. }finally{
  173. try{
  174. logger.info("关闭服务器");
  175. super.close();
  176. }catch(IOExceptione){
  177. logger.severe("服务器关闭失败："+e.getMessage());
  178. }
  179. }
  180. }
  182. /**
  183. *一个服务器实例，根据目前设计，一个终端的一次会话对应一个实例
  184. *单例模式，懒汉
  185. */
  186. publicstaticclassInstantimplementsRunnable{
  187. privateSocketsocket;
  189. publicInstant(Socketsocket){
  190. this.socket=socket;
  191. }
  193. publicSocketgetSocket(){
  194. returnsocket;
  195. }
  197. publicvoidrun(){
  198. logger.info("成功创建一个连接，等待客户端数据");
  200. Messagereponse;
  201. try{
  202. reponse=newReceiver(socket).process();
  203. logger.info("数据处理完成，发送响应");
  205. Sendersender=newSender(socket);
  206. if(reponse!=null){
  207. sender.send(reponse);
  208. }
  210. //总在最后发送关闭消息
  211. Messageclose=newDisconnectMessage();
  212. sender.send(close);
  214. logger.info("连接处理完成并关闭");
  215. }catch(Exceptione){
  216. InetAddressad=socket.getInetAddress();
  217. logger.warning("消息处理发生错误:"+e.getMessage()+"@"+ad.getCanonicalHostName());
  218. }finally{
  219. try{
  220. socket.close();
  221. }catch(IOExceptione){
  222. e.printStackTrace();
  223. }
  224. }
  225. }
  226. }
  228. publicstaticvoidmain(String[]args){
  229. logger.info("开始启动服务器");
  230. Server.newInstant().start();
  231. }
  232. }
  236. packagecom.nbchina.tcp.server;
  237. importjava.net.Socket;
  238. importjava.util.logging.Logger;
  240. importcom.nbchina.tcp.dao.StubDao;
  241. importcom.nbchina.tcp.msg.Message;
  242. importcom.nbchina.tcp.msg.ResponseMessage;
  243. importcom.nbchina.tcp.msg.UpdateMessage;
  246. /**
  247. *接收并解析编码
  248. *
  249. */
  250. publicclassReceiver{
  251. protectedstaticLoggerlogger=Logger.getLogger(Receiver.class.getName());
  253. privateSocketsocket;
  255. privateStubDaodao;
  257. publicReceiver(Socketsocket){
  258. this.socket=socket;
  260. this.dao=newStubDao();
  261. }
  263. publicMessageprocess()throwsException{
  264. UpdateMessagerequest=newUpdateMessage(socket.getInputStream());
  266. //判断是否是处理过的终端
  267. Stringid=request.getId();
  268. if(!dao.hasRegister(id)){
  269. //未处理过的，先注册（注册完以后，也应该查询是否有更新，可能是服务端已经录入了终端的注册信息）
  270. dao.register(id);
  271. }
  273. Messagereponse=null;
  274. if(dao.isUpdated(id)){
  275. //是处理过的，查询更新信息
  276. reponse=newResponseMessage(dao.fillMessageDetail(id));
  277. }
  279. returnreponse;
  280. }
  281. }
  285. packagecom.nbchina.tcp.server;
  287. importjava.io.DataOutputStream;
  288. importjava.net.Socket;
  289. importjava.util.logging.Logger;
  291. importcom.nbchina.tcp.msg.Message;
  293. /**
  294. *负责发送消息
  295. */
  296. publicclassSender{
  297. protectedstaticLoggerlogger=Logger.getLogger(Sender.class.getName());
  299. privateSocketsocket;
  301. publicSender(Socketsocket){
  302. this.socket=socket;
  303. }
  305. publicvoidsend(Messagemsg)throwsException{
  306. DataOutputStreamdos=newDataOutputStream(socket.getOutputStream());
  307. int[]data=msg.getData();
  308. for(intd:data){
  309. dos.write(d);
  310. }
  312. dos.flush();
  313. }
  314. }
  316. .....还有其他一些类

 

网络获取图片、html

[java]view plaincopyprint?
 
  1. publicclassHtmlRequest{
  2. publicstaticvoidmain(String[]args)throwsException{
  3. URLurl=newURL("http://www.sohu.com/");
  4. HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
  5. conn.setRequestMethod("GET");
  6. conn.setConnectTimeout(5*1000);
  7. InputStreaminStream=conn.getInputStream();//通过输入流获取html数据
  8. byte[]data=readInputStream(inStream);//得到html的二进制数据
  9. Stringhtml=newString(data,"utf-8");
  11. System.out.println(html);
  13. /*FileimageFile=newFile("nbchina.htm");
  14. FileOutputStreamoutStream=newFileOutputStream(imageFile);
  15. outStream.write(data);
  16. outStream.close();*/
  18. }
  20. publicstaticbyte[]readInputStream(InputStreaminStream)throwsException{
  21. ByteArrayOutputStreamoutStream=newByteArrayOutputStream();
  22. byte[]buffer=newbyte[1024];
  23. intlen=0;
  24. while((len=inStream.read(buffer))!=-1){
  25. outStream.write(buffer,0,len);
  26. }
  27. inStream.close();
  28. returnoutStream.toByteArray();
  29. }
  30. }
  34. publicclassImageRequest{
  35. publicstaticvoidmain(String[]args)throwsException{
  36. URLurl=newURL("http://img04.taobaocdn.com/bao/uploaded/i4/T1hTSvXihAXXbeLMw1_041248.jpg_b.jpg");
  37. HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
  38. conn.setRequestMethod("GET");
  39. conn.setConnectTimeout(5*1000);
  40. InputStreaminStream=conn.getInputStream();//通过输入流获取图片数据
  41. byte[]data=readInputStream(inStream);//得到图片的二进制数据
  42. FileimageFile=newFile("nbchina.jpg");
  43. FileOutputStreamoutStream=newFileOutputStream(imageFile);
  44. outStream.write(data);
  45. outStream.close();
  46. }
  48. publicstaticbyte[]readInputStream(InputStreaminStream)throwsException{
  49. ByteArrayOutputStreamoutStream=newByteArrayOutputStream();
  50. byte[]buffer=newbyte[1024];
  51. intlen=0;
  52. while((len=inStream.read(buffer))!=-1){
  53. outStream.write(buffer,0,len);
  54. }
  55. inStream.close();
  56. returnoutStream.toByteArray();
  57. }
  58. }


多线程下载

[java]view plaincopyprint?
 
  1. publicclassMulThreadDownload{
  3. publicstaticvoidmain(String[]args){
  4. Stringpath="http://dl_dir.qq.com/qqfile/qq/QQ2011/QQ2011.exe";
  5. try{
  6. newMulThreadDownload().download(path,5);
  7. }catch(Exceptione){
  8. e.printStackTrace();
  9. }
  10. }
  11. /**
  12. *从路径中获取文件名称
  13. *@parampath下载路径
  14. *@return
  15. */
  16. publicstaticStringgetFilename(Stringpath){
  17. returnpath.substring(path.lastIndexOf('/')+1);
  18. }
  19. /**
  20. *下载文件
  21. *@parampath下载路径
  22. *@paramthreadsize线程数
  23. */
  24. publicvoiddownload(Stringpath,intthreadsize)throwsException{
  25. URLurl=newURL(path);
  26. HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
  27. conn.setRequestMethod("GET");
  28. conn.setConnectTimeout(5*1000);
  29. intfilelength=conn.getContentLength();//获取要下载的文件的长度
  30. Stringfilename=getFilename(path);//从路径中获取文件名称
  31. FilesaveFile=newFile(filename);
  32. RandomAccessFileaccessFile=newRandomAccessFile(saveFile,"rwd");
  33. accessFile.setLength(filelength);//设置本地文件的长度和下载文件相同
  34. accessFile.close();
  35. //计算每条线程下载的数据长度
  36. intblock=filelength%threadsize==0?filelength/threadsize:filelength/threadsize+1;
  37. for(intthreadid=0;threadid<threadsize;threadid++){
  38. newDownloadThread(url,saveFile,block,threadid).start();
  39. }
  40. }
  42. privatefinalclassDownloadThreadextendsThread{
  43. privateURLurl;
  44. privateFilesaveFile;
  45. privateintblock;//每条线程下载的数据长度
  46. privateintthreadid;//线程id
  48. publicDownloadThread(URLurl,FilesaveFile,intblock,intthreadid){
  49. this.url=url;
  50. this.saveFile=saveFile;
  51. this.block=block;
  52. this.threadid=threadid;
  53. }
  55. @Override
  56. publicvoidrun(){
  57. //计算开始位置公式：线程id*每条线程下载的数据长度=？
  58. //计算结束位置公式：（线程id+1）*每条线程下载的数据长度-1=?
  59. intstartposition=threadid*block;
  60. intendposition=(threadid+1)*block-1;
  61. try{
  62. RandomAccessFileaccessFile=newRandomAccessFile(saveFile,"rwd");
  63. accessFile.seek(startposition);//设置从什么位置开始写入数据
  64. HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
  65. conn.setRequestMethod("GET");
  66. conn.setConnectTimeout(5*1000);
  67. conn.setRequestProperty("Range","bytes="+startposition+"-"+endposition);
  68. InputStreaminStream=conn.getInputStream();
  69. byte[]buffer=newbyte[1024];
  70. intlen=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(Exceptione){
  79. e.printStackTrace();
  80. }
  81. }
  82. }
  84. }
分享到：
| 软件测试学习：动态黑盒测试
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics