黑马程序员技术交流社区

标题: javaIO 帮我找下错误啊 [打印本页]
作者: 江南    时间: 2012-6-10 02:50
标题: javaIO 帮我找下错误啊
头晕晕的了，不知道客户端为什么得不到数据 猜测就是在流的写入写出被阻塞，出了问题了！太累了怎么都看不出来
import java.io.*;
import java.net.*;

class PicClien
{   
          public static void main(String []  args)throws Exception
          {
                  Socket s=new Socket("192.168.1.254",1007);
                  FileInputStream fis=new FileInputStream("c:\\1.bmp");
                  OutputStream  out=s.getOutputStream();
                  byte[] buf=new byte[1024];
                  int len=0;
                  while((len=fis.read(buf))!=-1)
                  {
                          out.write(buf,0,len);
                  }
                  InputStream in=s.getInputStream();
                  byte[] bufIn= new byte[1024];
                  int num=in.read(bufIn);
                  System.out.println(new String(bufIn,0,num));
                  fis.close();
                  s.close();
          }
}


class  PicServer
{
        public static void main(String[] args)throws Exception
        {
                ServerSocket ss= new ServerSocket(1007);
                Socket s=ss.accept();
                InputStream in=s.getInputStream();
                FileOutputStream fos= new FileOutputStream("server.bmp");
                byte[] buf= new byte[1024];
                 
                int len=0;
                while((len=in.read(buf))!=-1)
                {
       fos.write(buf,0,len);               
                }
                OutputStream out= s.getOutputStream();
                out.write("上传成功".getBytes());
                fos.close();
                s.close();
                ss.close();
        }

}
作者: 潘东升    时间: 2012-6-10 03:30

客户端传完图片后，但是并没有发送结束标记，所以服务端并不知道已经传完了，一直在等着接收文件，只有给服务端发送结束标记才行，可以约定一个结束标记，比如在最后发送个“over”之类的，这样服务端接到之后就知道接收完成了，才会给客户端回馈信息，但是这样不专业也容易出问题，比如如果文件内有“over”内容就会出错，所以Socket有自定一个shundownOutput方法，传完文件后调用该方法关闭其输出流，实际就是在向服务端发送文件上传结束标记，看图：

还有，最好把刷新流，因为用到了字节数组缓冲，凡是有缓冲的都要刷新，免得数据丢失。
作者: 赵兵锋    时间: 2012-6-10 03:48
本帖最后由 赵兵锋 于 2012-6-10 03:49 编辑
  1. public class PicServer {
  2.         public static void main(String[] args) throws Exception {
  3.                 ServerSocket ss = new ServerSocket(1007);
  4.                 Socket s = ss.accept();
  5.                 InputStream in = s.getInputStream();
  6.                 FileOutputStream fos = new FileOutputStream("e:/server.jpg");
  7.                 byte[] buf = new byte[1024];
  8.                 OutputStream out = s.getOutputStream();
  9.                 int len = 0;
  10.                 while ((len = in.read(buf)) ==1024) {//只有当客户端的输出流close后，此处的len才会为-1，但客户端若将输出流关掉，连接也会关掉。所以这里以读出的是否是1024个字节判断，不是1024就表示这是最后一组数据了
  11.                         fos.write(buf, 0, len);
  12.                 }
  13.                 fos.write(buf, 0, len);//将最后一组数据写入到文件
  14.                 fos.flush();
  15.                 fos.close();//文件流可以关掉了
  16.                 out.write("上传成功".getBytes());
  17.                 out.flush();//写后一定要flush一下，强制将输出缓冲区中数据清空，写入流中
  18.                 in.close();//此时才可以关输入流，提早关会导致连接关闭
  19.                 s.close();
  20.                 ss.close();
  21.         }
  22. }
复制代码
  1. public class PicClient {
  2.         public static void main(String []  args)throws Exception
  3.     {
  4.             Socket s=new Socket("127.0.0.1",1007);
  5.             FileInputStream fis=new FileInputStream("e:/1.jpg");
  6.             OutputStream  out=s.getOutputStream();
  7.             byte[] buf=new byte[1024];
  8.             int len=0;
  9.             while((len=fis.read(buf))!=-1)
  10.             {               
  11.                     out.write(buf,0,len);
  12.             }
  13.             out.flush();//一定要有这步，保证数据都传过去了
  14.             fis.close();//文件流这时可以关了
  15.             InputStream in=s.getInputStream();//在此之前一定不能关闭out，不然连接也会关闭，这里就会报错
  16.             byte[] bufIn= new byte[1024];
  17.             int num=in.read(bufIn);
  18.             System.out.println(new String(bufIn,0,num));
  19.             out.close();//此时才可以关闭流
  20.             s.close();
  21.     }
  22. }
复制代码
作者: 杨天皓    时间: 2012-6-10 03:56
上面那位兄弟已经说的很明白了，没有结束标记，服务端会一直等客户端传数据。
给你一个我写的加入缓冲区，及时刷新的，可以有效的防止数据丢失。
  1. import java.io.*;
  2. import java.net.*;


  5. class TcpServer {

  7.         /**
  8.          * @param args
  9.          */
  10.         private static BufferedOutputStream bw;
  11.         private static BufferedInputStream brIn;

  13.         public static void main(String[] args) {
  14.                 // TODO Auto-generated method stub
  15.                 try {
  16.                         ServerSocket ss = new ServerSocket(11000);

  18.                         Socket sk = ss.accept();

  20.                         brIn = new BufferedInputStream(sk.getInputStream());

  22.                         bw = new BufferedOutputStream(new FileOutputStream("d:\\1.jpg"));
  23.                        
  24.                         byte[] buf = new byte[1024];
  25.                         int len = 0;
  26.                         while((len = brIn.read(buf))!=-1){
  27.                                 bw.write(buf,0,len);
  28.                                 bw.flush();
  29.                         }
  30.                         OutputStream out = sk.getOutputStream();
  31.                         out.write("上传成功".getBytes());

  33.                 } catch (IOException e) {
  34.                         // TODO Auto-generated catch block
  35.                         e.printStackTrace();
  36.                 }
  37.         }

  39. }




  44. class TcpClient {

  46.         /**
  47.          * @param args
  48.          */
  49.         private static BufferedInputStream br;
  50.         private static BufferedOutputStream bfout;
  51.         private static Socket sk;

  53.         public static void main(String[] args) {
  54.                 // TODO Auto-generated method stub
  55.                

  57.                 try {
  58.                         sk = new Socket("192.168.1.254",11000);
  59.                        
  60.                         br = new BufferedInputStream(new FileInputStream("c:\\1.jpg"));
  61.                         bfout = new BufferedOutputStream(sk.getOutputStream());

  63.                         byte[] buf = new byte[1024];
  64.                        
  65.                         int len = 0;
  66.                        
  67.                         while((len=br.read(buf))!= -1){
  68.                                 bfout.write(buf,0,len);
  69.                                 bfout.flush();
  70.                         }
  71.                        
  72.                         sk.shutdownOutput();
  73.                         InputStream in = sk.getInputStream();
  74.                         byte[] bufIn = new byte[1024];

  76.                         int num = in.read(bufIn);
  77.                         System.out.println(new String(bufIn,0,num));



  81.                 } catch (IOException e) {
  82.                         // TODO Auto-generated catch block
  83.                         e.printStackTrace();
  84.                 } finally {
  85.                         try {
  86.                                 if (br != null)
  87.                                         br.close();
  88.                         } catch (IOException e) {
  89.                                 e.printStackTrace();
  90.                         }
  91.                         try {
  92.                                 if (bfout != null)
  93.                                         bfout.close();
  94.                         } catch (IOException e) {
  95.                                 e.printStackTrace();
  96.                         }
  97.                         try {
  98.                                 if (sk != null)
  99.                                         sk.close();
  100.                         } catch (IOException e) {
  101.                                 e.printStackTrace();
  102.                         }
  103.                 }
  104.         }
  105. }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2