`

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. }
分享到：
| 软件测试学习：动态黑盒测试
评论
发表评论

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

相关推荐

    TCP网络编程实例

    总的来说，TCP网络编程实例为开发者提供了一个实用的学习资源，涵盖了TCP连接的完整生命周期，以及在不同计算机间实现通信的关键技术。通过深入研究和实践，你将能够熟练掌握TCP编程，为构建可靠的网络应用打下坚实...

    c#网络编程实例教程源代码

    《C#网络编程实例教程源代码》是一份深入浅出的教学资源，旨在帮助开发者掌握C#语言在网络编程领域的应用。这份教程结合了理论与实践，提供了丰富的源代码示例，让学习者能够通过实际操作来理解和掌握网络编程的核心...

    Linux网络编程示例，TCP和UDP

    本压缩包文件聚焦于Linux环境下的网络编程，主要涉及TCP（传输控制协议）和UDP（用户数据报协议）这两种常见的网络通信协议。以下是基于提供的信息，对Linux网络编程中的TCP和UDP知识点的详细阐述： 1. **Linux ...

    单片机TCP网络编程的实例

    总结来说，"单片机TCP网络编程的实例"涉及了嵌入式系统与网络的融合，包括TCP/IP协议的理解、硬件接口的选择、协议栈的集成以及实际的数据传输。通过学习和实践，开发者可以构建出能够联网的智能设备，实现远程控制...

    c++网络编程实例.pdf

    C++ 网络编程实例 本文档提供了 C++ 网络编程的基础知识，涵盖了网络编程的概述、OSI 七层网络模型、TCP/IP 协议和 C/S 编程模型等内容。 网络编程概述 网络编程是指用户使用 MFC 类库在 VC 编译器中编写程序，以...

    《Java网络编程实例：Java网络编程实例》

    本书《Java网络编程实例：Java网络编程实例》显然聚焦于通过实际案例来教授这一核心技能。以下是一些主要的知识点，这些知识点通常会在书中详细讨论： 1. **TCP/IP协议基础**：首先，了解TCP/IP模型和协议栈是非常...

    socket TCP UDP编程实例

    在这个"socket TCP UDP编程实例"中，我们将会探讨如何在Windows环境下，利用Visual Studio 2015进行客户端和服务端的开发。 首先，TCP（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的...

    Socket网络编程_TCP实例

    本实例主要探讨如何在C#环境中利用Socket类进行TCP网络编程。 首先，我们需要理解C#中的Socket类。Socket是.NET Framework提供的一个基类，它封装了底层网络通信协议，如TCP或UDP，允许开发者发送和接收数据。创建...

    网络编程编程实例，包含18个实例和源代码

    本资源是一个网络编程的实践宝库，包含了18个精心设计的实例，每个实例都附带了完整的源代码，非常适合学习和参考。这些实例是使用经典的Visual C++ 6.0开发的，尽管这个版本相对较老，但它仍然是许多开发者理解和...

    TCP编程实例

    在LabVIEW中进行TCP编程，我们需要使用到“网络”函数库中的相关VI（Virtual Instruments）。这些VI包括“打开TCP客户端连接”、“打开TCP服务器连接”、“发送TCP数据”、“接收TCP数据”等。以下是一些关键步骤的...

    VC网络编程实例_3

    （1）基本网络编程实例 Winsock实现网络聊天室【\chap1\ChatRoom(Winsock)】 CSocket实现聊天室【\chap1\ChatRoom(Csocket)】 （2）本地计算机网络编程实例 获取计算机的名称和IP地址【\chap2\Local】 获取计算机的...

    JAVA网络编程实例（TCP通信）

    Java网络编程是构建分布式应用程序的关键技术之一，尤其是在服务器...通过上述的Java TCP通信实例，我们可以了解到Java网络编程的基本原理和操作步骤，这对于理解网络通信机制以及开发网络应用程序具有重要的指导意义。

    MFC网络编程实例

    **MFC网络编程实例** MFC（Microsoft Foundation Classes）是微软提供的一套C++类库，用于构建Windows应用程序。在MFC中进行网络编程，主要是通过封装Winsock API实现的，这使得开发者能够更容易地创建支持网络通信...

    Linux下的基于TCP的网络编程实例

    Linux下的基于TCP的网络编程实例，使用了多进程模式。代码较小，能快速掌握。

    java网络编程实例2

    这个"java网络编程实例2"很可能包含了深入的实践案例，帮助读者理解并掌握网络编程的基本概念和技术。以下是根据标题和描述可能涵盖的一些关键知识点： 1. **网络基础知识**：在Java中进行网络编程首先需要了解TCP/...

    c++网络编程实例开发

    本项目“c++网络编程实例开发”提供了一系列基于C++的网络编程实例，涵盖了事件处理、线程管理和连接处理等核心概念。 首先，我们要理解网络编程的基本原理。网络编程是让计算机通过网络进行通信的过程，它涉及到...

    几个TCP/IP编程实例,WinSock编程，聊天实例

    本主题聚焦于“TCP/IP编程实例，WinSock编程，聊天实例”，将深入探讨这些关键概念和技术。 TCP/IP协议栈是互联网的基础，它定义了一套标准的数据传输规则，使得不同设备之间能够进行有效的通信。TCP（Transmission...

    Java网络编程/Java网络编程实例

    Java网络编程是Java开发中的重要领域，它涵盖了网络应用...提供的《Java网络编程实例》将可能包含这些概念的具体代码示例，帮助读者更好地理解和掌握相关技术。阅读和分析这些实例，是提升Java网络编程技能的有效途径。

    sql网络编程实例

    《SQL网络编程实例》这份教程，正如其名，主要探讨的是如何在分布式环境中利用SQL进行数据交互和处理。SQL（Structured Query Language），即结构化查询语言，是用于管理和操作数据库的标准语言，尤其在网络编程中起...

    基于ｔｃｐ的ｓｏｃｋｅｔ编程实例

    在这个"基于TCP的socket编程实例"中，我们将深入探讨如何使用socket API进行TCP通信，并通过"main"这个程序文件来理解其实现过程。 首先，TCP socket编程主要包括服务器端和客户端两部分。服务器端需要先启动，监听...

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