一个关于Socket，IO的小问题，请教各位高人

我是一个初学者，编了个小练习。在编译时通过，在运行时出现在问题。望各位高人指点一二，在这谢过了！！！

服务端

import java.net.*;
import java.io.*;

class NetServer{
	public static void main(String []args) {

	try {
		ServerSocket ss =new ServerSocket(8888);


		while(true) {		
			Socket s = ss.accept();
			System.out.print("A is client connect");
			DataInputStream dis = new DataInputStream(s.getInputStream());			
			System.out.println(dis.readUTF());
		}

	} catch(IOException e) {
		e.printStackTrace();
	} catch(Exception e) {
		e.printStackTrace();
	}

	}
}

客户端：

import java.net.*;
import java.io.*;

class Cline {
	public static void main(String []args) {
		String str = null;
		DataInputStream dis = null;
		DataOutputStream dos = null;

		try {
			Socket s = new Socket("127.0.0.1",8888);			

			while(true) {
				dis = new DataInputStream(System.in);
				str = dis.readUTF();
				dos = new DataOutputStream(s.getOutputStream());
				dos.writeUTF(str);
			}

		} catch(Exception e) {
			e.printStackTrace();
		}
	}
}

运行时分别出现了下面的错误：

D:\java\netSocket>java NetServer
A is client connectjava.net.SocketException: Connection reset
        at java.net.SocketInputStream.read(Unknown Source)
        at java.net.SocketInputStream.read(Unknown Source)
        at java.io.DataInputStream.readUnsignedShort(Unknown Source)
        at java.io.DataInputStream.readUTF(Unknown Source)
        at java.io.DataInputStream.readUTF(Unknown Source)
        at NetServer.main(NetServer.java:15)



java.io.IOException: 存放體空間不足，無法處理此指令。
        at java.io.FileInputStream.readBytes(Native Method)
        at java.io.FileInputStream.read(Unknown Source)
        at java.io.BufferedInputStream.read1(Unknown Source)
        at java.io.BufferedInputStream.read(Unknown Source)
        at java.io.DataInputStream.readFully(Unknown Source)
        at java.io.DataInputStream.readUTF(Unknown Source)
        at java.io.DataInputStream.readUTF(Unknown Source)
        at Cline.main(Cline.java:15)

21 个解决方案

#1

你的dis和dos没关闭。

#2

我调用了 close()方法后怎么还有相同的错误？

#3

你写的根本就不对，你把 DataInputStream dis = new DataInputStream(s.getInputStream()); 和dos………………放到了循环里面一直new，当然出错了，你要操作的是一个流对象，不是N个

#4

我修改成这样还是不行，到底是什么问题？

import java.net.*;
import java.io.*;

class NetServer{
    public static void main(String []args) {

    try {
        ServerSocket ss =new ServerSocket(8888);   
     
            Socket s = ss.accept();
            System.out.print("A is client connect");
            DataInputStream dis = new DataInputStream(s.getInputStream());            
            System.out.println(dis.readUTF());
            dis.close();

    } catch(IOException e) {
        e.printStackTrace();
    } catch(Exception e) {
        e.printStackTrace();
    }

    }
}

import java.net.*;
import java.io.*;

class Cline {
    public static void main(String []args) {
        String str = null;
        DataInputStream dis = null;
        DataOutputStream dos = null;

        try {
            Socket s = new Socket("127.0.0.1",8888); 
            dis = new DataInputStream(System.in);
            dos = new DataOutputStream(s.getOutputStream()); 
                          
            str = dis.readUTF();
            dos.writeUTF(str);
						dos.close();
						dis.close();

        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}

#5

你的输入输出流怎么是这样的？你从控制台获得字符流的形式数据，再流这个数据给服务器，数据发送结束后，再刷新客户端输出流，最后关闭客户端这个输出流就可以了。

#6

你现在是没理解dis 和 dos应该如何操作
拿dos来说，它被创建好后，应该是循环写到输出流中，既不是你刚开始写的循环的去new它，也不是你第二次写的不给它循环。
给你一段我写的接受端的代码，测试过的传送二进制文件的，根据这个去想想server发送端应该怎么写，原理差不多。

因为只考虑功能，没有异常处理

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.Socket;

public class Test {
	private void connect() {
		byte b[] = new byte[512];//缓冲区
		int num = 0;
		try {
			Socket socket = new Socket("localhost", 7777);
			InputStream is = socket.getInputStream();
			FileOutputStream fw = new FileOutputStream("c:/new.pdf");
			num = is.read(b);			//读一下数据流
			while (num != (-1)) {		// 是否读完所有数据
				fw.write(b, 0, num);	// 将数据写往文件
				num = is.read(b);		// 继续从文件中读取数据
			}
			is.close();
			fw.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

#7

呵呵，路过，兄弟，加油呀！

#8

发个例子给你看看吧

import java.io.*;
import java.net.*;

public class ChatServer {



public static void main(String[] args) {
boolean started = false;
try {
ServerSocket ss = new ServerSocket(8888);
started = true;
while(started) {
boolean bConnected = false;
Socket s = ss.accept();
System.out.println("a client connected!");
bConnected = true;
DataInputStream dis = new DataInputStream(s.getInputStream());
while(bConnected) {
String str = dis.readUTF();
System.out.println(str);
}
dis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}

}

#9

不好意思弄错了

import java.io.*;
import java.net.*;

public class ChatServer {



	public static void main(String[] args) {
		boolean started = false;
		try {
			ServerSocket ss = new ServerSocket(8888);
			started = true;
			while(started) {
				boolean bConnected = false;
				Socket s = ss.accept();
System.out.println("a client connected!");
				bConnected = true;
				DataInputStream dis = new DataInputStream(s.getInputStream());
				while(bConnected) {
					String str = dis.readUTF();
					System.out.println(str);
				}
				dis.close();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

#10

根据上面说的，我改了下我的代码，还是有问题。我真的不知问题出现在那里。有没有那位帮我调下我这两段代码，修改下。指出下问题所在。谢谢！！！

import java.io.*;
import java.net.Socket;

public class Cline {
    private void connect() {
        String  str = null;
        
        try {
            Socket socket = new Socket("localhost", 8888);
            InputStream is = socket.getInputStream();
            FileOutputStream fw = new FileOutputStream("F:/javacode/new.txt");
            DataInputStream dis = new DataInputStream(is);
            DataOutputStream dos = new DataOutputStream(fw);
            str = dis.readUTF();            //读一下数据流
            while (str != null) {        // 是否读完所有数据
                dos.writeUTF(str);    // 将数据写往文件
                str = dis.readUTF();        // 继续从文件中读取数据
            }
            dos.flush();
            dos.close();
            dis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String args[]) {
    	new Cline().connect();
    }
}

import java.net.*;
import java.io.*;

class NetServer{
    public static void main(String []args) {

    try {
        ServerSocket ss =new ServerSocket(8888);   
     
     				OutputStream os = null;
     				FileInputStream fis = null;
     				DataInputStream dis = null;
     				DataOutputStream dos = null;
     				String str = null;
     				
            Socket s = ss.accept();
            System.out.print("A is client connect");
            fis = new FileInputStream("F:/javacode/Runnables.java");
 						os = s.getOutputStream();
            dis = new DataInputStream(fis);
						dos = new DataOutputStream(os);
						str = dis.readUTF();

            while( str != null) {          
           		dos.writeUTF(str);
           }
          
          	dos.flush();
          	dos.close();
            dis.close();

    } catch(IOException e) {
        e.printStackTrace();
    } catch(Exception e) {
        e.printStackTrace();
    }

    }
}

#11

这里有我以前用Socket写的一个聊天室的例子，楼主可以去看看。不妨自己copy下来运行一下。http://blog.csdn.net/doudou15223155621/archive/2010/03/21/5402190.aspx

#12

http://blog.csdn.net/doudou15223155621/archive/2010/03/21/5402190.aspx 
这个例子里有用到多线程，最好有一定了解线程的使用，才看得明白。希望对你有所帮助吧。

#13

谢谢楼上的！

#14

谢谢大家,本来我有相同的问题,看来不用开新帖了.

#15

接收端：

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.Socket;

public class AcceptFile {

 private void connect() {
  byte b[] = new byte[512];
  int num = 0;
  try {
   Socket socket = new Socket("localhost", 7777);
   InputStream is = socket.getInputStream();
   FileOutputStream fw = new FileOutputStream("c:/newjcl.pdf");
   num = is.read(b);
   while (num != (-1)) {// 是否读完所有数据
    fw.write(b, 0, num);// 将数据写往文件
    num = is.read(b);// 继续从文件中读取数据
   }
   is.close();
   fw.close();
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 public static void main(String[] args) {
  AcceptFile af = new AcceptFile();
  af.connect();
 }
}

发送端：

import java.io.FileInputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Test3 {

 public static void main(String args[]) {
  int num = 0;
  byte b[] = new byte[512];
  try {
   ServerSocket server = new ServerSocket(7777);
   Socket socket = server.accept();
   FileInputStream fis = new FileInputStream("c:/jcl.pdf");
   OutputStream fos = socket.getOutputStream();
   num = fis.read(b);
   while (num != (-1)) {// 是否读完文件
    fos.write(b,0,num);// 把文件数据写出网络缓冲区
    fos.flush();// 刷新缓冲区把数据写往客户端
    num = fis.read(b);//继续从文件中读取数据
   }
   fos.close();

  } catch (Exception e) {
   e.printStackTrace();
  }
 }
}

#16

谢谢楼上的了，我今天也有按你的这思路写了下。我把 flush()方法放到循环外了。弄得我。。。。。。
还是对这些类的方法没有理解。

#17

按我最后改的，怎么就不行呢。有没有人指出下问题的所在啊？

#18

你代码的片段，接收端的。

import java.io.*;
import java.net.Socket;

public class Cline {
    private void connect() {
        String  str = null;
        
        try {
            Socket socket = new Socket("localhost", 8888);
            InputStream is = socket.getInputStream();
            FileOutputStream fw = new FileOutputStream("F:/javacode/new.txt");
            DataInputStream dis = new DataInputStream(is);
            DataOutputStream dos = new DataOutputStream(fw);

DataInputStream dis = new DataInputStream(is);
DataOutputStream dos = new DataOutputStream(fw);
你要这两句来干什么呢？
接收端需要做3件事
1、拿到对于接收端来说是 in 方向的流，即InputStream is = socket.getInputStream();整个流是从socket来的，这句话你就得到了。
2、把这个流写到文件，即FileOutputStream fw = new FileOutputStream（"F:/javacode/new.txt");
3、怎么写呢？ 当然是用循环写，吧in的内容，写到fw里面去！
这样就完成了。

发送端要做什么？
1、把要发送的东西变成货物，即--流 fis = new FileInputStream("F:/javacode/Runnables.java");

2、流要怎么送出去？当然是坐车，即OutputStream fos = socket.getOutputStream();fos就是汽车，但是汽车可能需要分批发送这些流。
3、把流扔进车里，即while循环部分，fos.flush();的意思就是“发车”，然后让下批货物上车
==========================================

你写了一些不必要的东西，以上就是原理 和 我的代码和你的代码的对比

#19

嗯，非常感谢！

#20

我的原来的思路是这样的，在服务端：用 dis = new DataInputStream(fis);str = dis.readUTF();读取："F:/javacode/Runnables.java"目录下的文件。
用dos = new DataOutputStream(os);dos.writeUTF(str);把文件的内容写出去。
在客户端也是用这两方法读取和把文件内容写到new.txt文件里去。

你用的方法是按字节读取写，我用的是按字符串读写。在编译时通过，运行时却出现了这些错误：

java.net.SocketException: Connection reset
        at java.net.SocketInputStream.read(Unknown Source)
        at java.net.SocketInputStream.read(Unknown Source)
        at java.io.DataInputStream.readUnsignedShort(Unknown Source)
        at java.io.DataInputStream.readUTF(Unknown Source)
        at java.io.DataInputStream.readUTF(Unknown Source)
        at Cline.connect(Cline.java:14)
        at Cline.main(Cline.java:29)

A is client connectjava.io.EOFException
        at java.io.DataInputStream.readFully(Unknown Source)
        at java.io.DataInputStream.readUTF(Unknown Source)
        at java.io.DataInputStream.readUTF(Unknown Source)
        at NetServer.main(NetServer.java:22)

#21

我修改了我读写文件的方法，用这个方法可以读写成功。先前的为什么不可以：有人能说出这两者之间的区别吗，最好能详细说下。在这先谢了！

import java.net.*;
import java.io.*;

class NetServer{
    public static void main(String []args) {

    try {
        ServerSocket ss =new ServerSocket(8888);   
     
     				OutputStream os = null;
     				FileInputStream fis = null;
     				InputStreamReader isr = null;
     				BufferedReader br = null;
     				BufferedWriter bw = null;
     				OutputStreamWriter osw = null;
     				String str = null;
     				
            Socket s = ss.accept();
            System.out.print("A is client connect");
            fis = new FileInputStream("F:/javacode/Runnables.java");
 						os = s.getOutputStream();
            isr = new InputStreamReader(fis);            
            br = new BufferedReader(isr);
						osw = new OutputStreamWriter(os);
						bw = new BufferedWriter(osw);

						str = br.readLine();

            while( str != null) {          
           		bw.write(str,0,str.length());
           		bw.flush();
           		str = br.readLine();
           }          

          	bw.close();
            br.close();

    } catch(IOException e) {
        e.printStackTrace();
    } catch(Exception e) {
        e.printStackTrace();
    }

    }
}

import java.io.*;
import java.net.Socket;

public class Cline {
    private void connect() {
        String  str = null;
        
        try {
            Socket socket = new Socket("localhost", 8888);
            InputStream is = socket.getInputStream();
            FileOutputStream fw = new FileOutputStream("F:/javacode/new.txt");
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);
            OutputStreamWriter osw = new OutputStreamWriter(fw);
            BufferedWriter bw = new BufferedWriter(osw);
            str = br.readLine();            //读一下数据流
            while (str != null) {        // 是否读完所有数据
                bw.write(str,0,str.length());    // 将数据写往文件
                bw.flush();
                str = br.readLine();        // 继续从文件中读取数据                
            }

            bw.close();
            br.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String args[]) {
    	new Cline().connect();
    }
}