题目是这样的编写一个Java网络应用程序,该应用分服务器端程序和客户端程序两部分。服务器程序启动后,监听端口5678的请求;客户端程序启动后,向服务器端口5678发送请求。服务器不断接收客户机所写入的信息,并且服务器也会做出"Receive"为回应,告知客户机已接收到消息。要求:服务器程序采用多线程开发,允许多个客户端程序同时连接。客户机发送"End"字符串时,客户端程序退出。(服务端程序和客户端程序分别命名为Server.java和Client.java)
功能差不多完成了,就剩下怎么实现多个客户端连接到服务器??请问谁帮我写下好吗?希望今天帮我解决下谢谢
客户端
package 第三届;import java.io.*;
import java.net.*;public class SampleClient {
public static void main(String[] arges) {
try {
Socket s1 = new Socket("127.0.0.1", 5678);
InputStream is = s1.getInputStream();
DataInputStream dis = new DataInputStream(is);
OutputStream os = s1.getOutputStream();
DataOutputStream dos = new DataOutputStream(os);
        new MyserverReader(dis).start();
new MyserverWriter(dos).start();
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }
}class MyclientReader extends Thread { private DataInputStream dis; MyclientReader(DataInputStream dis) {
this.dis = dis; } @Override
public void run() {
// TODO Auto-generated method stub
String info = null;
while (true) { try {
info = dis.readUTF();
System.out.println("对方说" + info);
if (info.equals("end")) {
System.out.println("程序退出");
System.exit(0);
} } catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} } }}class MyClientWriter extends Thread { private DataOutputStream dos; public MyClientWriter(DataOutputStream dos) {
this.dos = dos;
} public void run() { InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String info; while (true) {
try {
info = br.readLine();
dos.writeUTF(info);
if (info.equals("end")) {
System.out.println("程序退出");
System.exit(0);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} } }}服务器端:
package 第三届;import java.net.*;
import java.io.*;public class SampleServer extends Thread {
static BufferedReader in;
static PrintWriter out; public static void main(String[] arges) { try { // 使用5678端口创建一个ServerSocket
ServerSocket mySocket;
mySocket = new ServerSocket(5678);
while (true) {

// 等待监听是否有客户端连接
Socket sk = mySocket.accept();
// 接受从客户端过来的数据流
OutputStream os = sk.getOutputStream();
DataOutputStream dos = new DataOutputStream(os);
InputStream is = sk.getInputStream();
DataInputStream dis = new DataInputStream(is);
new MyserverReader(dis).start();
new MyserverWriter(dos).start();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }
}class MyserverReader extends Thread {
private DataInputStream dis; public MyserverReader(DataInputStream dis) {
// TODO Auto-generated constructor stub
this.dis = dis;
} public void run() {
String info; while (true) {
try {
info = dis.readUTF();
System.out.println("对方说" + info);
if (info.equals("end")) {
System.out.println("程序退出");
System.exit(0);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} } }}class MyserverWriter extends Thread { private DataOutputStream dos; MyserverWriter(DataOutputStream dos) {
this.dos = dos;
} @Override
public void run() {
// TODO Auto-generatessuper.run();

String info = "receive";
while (true) {
try {
info = br.readLine();
dos.writeUTF(info);
if (info.equals("end")) {
System.out.println("程序退出,程序退出");
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} } }}麻烦大家了

解决方案 »

  1.   

    可以用 ExecutorService类 模拟客户端多用户向同一服务器端发送请求
    大致上的代码ExecutorService exec = Executors.newCachedThreadPool();
    Runnable runnable=createTask()
    exec.execute(runnable);
    System.out.println("Active Connection: "+(i+1));
    Thread.sleep(interval);private Runnable createTask() {
    return new Runnable() {
    public void run() {}
    };}
    你把你原来客户端代码移到run()方法里改改就成了
      

  2.   

    服务器端连接客户端的地方改一下
    while(true){
    try{
    Socket sk = mySocket.accept(); 
    new MyThread(sk).start();

    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    然后写一个类继承Thread,这个类的构造方法传进来Socket sk,然后在run方法里执行你想要的程序
    大概是这样
    class MyserverWriter extends Thread{
    private Socket s;
    public MyserverWriter (Socket s){
    this.s=s;
    }
    public void run(){
    OutputStream os = sk.getOutputStream();
    DataOutputStream dos = new DataOutputStream(os);
    InputStream is = sk.getInputStream();
    DataInputStream dis = new DataInputStream(is);
    new MyserverReader(dis).start();
    new MyserverWriter(dos).start();
    }
    } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }} 
    }
    }
    我看你的程序客户端写了两个Thread类,一个度消息,一个写消息,不建议这样,客户端的读记录的代码最好放在一个线程里,因为在客户端的主线程里最好不要阻塞,写就没有必要了吧
      

  3.   

    这是一个实际应用public void run(){
    logger.info("java socket 开始执行……");
    try {
    server = new ServerSocket(5678);
    } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    try{

    while(true){
    String firstValue = "";
    String returnStr = "";
    client = server.accept();
    BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
    PrintWriter out = new PrintWriter(client.getOutputStream());
    ExecuteSocketServer ess = new ExecuteSocketServer();
    String reciverInfo = in.readLine();
    String [] reciverValue = reciverInfo.split(",");
    if(reciverValue.length>0){
    //你的代码                          out.println("要返回的信息");
    }
    out.flush();
    client.close();
    }

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

    } }
      

  4.   

    该说的楼上说的差不多了,友情提醒,由于涉及到连接多个客户,你每个accept到的socket,都只要去get一次他们的inPutStream和outputStream胡乱多new的话会出现接收上的灵异事件~
      

  5.   

    服务端import java.net.*;
    import java.io.*;
    import java.util.Vector;
    import java.util.logging.Level;
    import java.util.logging.Logger;public class SampleServer extends Thread {    public static void main(String[] arges) {
            try {
                new MyServer(5678).start();
            } catch (IOException ex) {
                Logger.getLogger(SampleServer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }class MyServer extends Thread {    int port;    public MyServer(int p) throws IOException {
            if (p < 0) {
                throw new IOException("端口错误");
            }
            port = p;
        }    @Override
        public void run() {
            // 使用5678端口创建一个ServerSocket
            ServerSocket mySocket;
            Vector<MyServerRW> socket_list = new Vector();
            try {
                mySocket = new ServerSocket(port);
            } catch (IOException ex) {
                Logger.getLogger(MyServer.class.getName()).log(Level.SEVERE, null, ex);
                return;
            }
            while (true) {
                try {
                    // 等待监听是否有客户端连接
                    socket_list.add(new MyServerRW(mySocket.accept()));
                } catch (IOException ex) {
                    Logger.getLogger(MyServer.class.getName()).log(Level.SEVERE, null, ex);
                    return;
                }
            }
        }
    }class MyServerRW extends Thread {    Socket socket;
        private DataInputStream dis;
        private DataOutputStream dos;    public MyServerRW(Socket s) throws IOException {
            if (s == null) {
                throw new IOException("传入套接字不能为NULL");
            }
            socket = s;
            // 接受从客户端过来的数据流
            OutputStream os = s.getOutputStream();
            dos = new DataOutputStream(os);
            InputStream is = s.getInputStream();
            dis = new DataInputStream(is);
            this.start();
        }    @Override
        public void run() {
            /////////////////   如果是用户端发给别的用户端,可以在MyServerRW中多定义个用户id,然后在socket_list中查到需要发送到的用户
            String info;
            while (true) {
                try {
                    info = dis.readUTF();////可以自定义协议
                    if (info.equals("end")) {
                        System.out.println("与客户端断开连接");
                        dos.writeUTF("end");
                        dis.close();
                        dos.close();
                        socket.close();
                        break;
                    }
                    System.out.println("服务端收到并回发消息:" + info);
                    dos.writeUTF("收到消息:" + info);
                } catch (IOException e) {
                    e.printStackTrace();
                }        }    }
    }
    客户端import java.io.*;
    import java.net.*;
    import java.util.logging.Level;
    import java.util.logging.Logger;public class SampleClient{    public static void main(String[] arges) {
            try {
                MyClient mc = new MyClient("127.0.0.1", 5678);
                mc.write("测试消息");
                mc.write("end");
            } catch (IOException ex) {
                Logger.getLogger(SampleClient.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
    class MyClient  extends Thread {    private DataInputStream dis;
        private DataOutputStream dos;
        Socket socket;    public MyClient(String sip, int port) throws IOException {
            socket = new Socket(sip, port);
            InputStream is = socket.getInputStream();
            dis = new DataInputStream(is);
            OutputStream os = socket.getOutputStream();
            dos = new DataOutputStream(os);
            start();
        }    @Override
        public void run() {
            while (true) {
                try {
                    String inf = dis.readUTF();
                    if (inf.equals("end")) {
                        System.out.println("客户端断开连接");
                        break;
                    }
                    System.out.println("客户端收到消息:" + inf);
                } catch (IOException ex) {
                    Logger.getLogger(SampleClient.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            try {
                dis.close();
            } catch (IOException ex) {
                Logger.getLogger(SampleClient.class.getName()).log(Level.SEVERE, null, ex);
            }
            try {
                dos.close();
            } catch (IOException ex) {
                Logger.getLogger(SampleClient.class.getName()).log(Level.SEVERE, null, ex);
            }
            try {
                socket.close();
            } catch (IOException ex) {
                Logger.getLogger(SampleClient.class.getName()).log(Level.SEVERE, null, ex);
            }
        }    public void write(String msg) throws IOException {
            dos.writeUTF(msg);
            dos.flush();
        }}
    测试结果服务端
    debug:
    服务端收到并回发消息:测试消息
    与客户端断开连接
    成功生成(总时间:25 秒)
    客户端debug:
    客户端收到消息:you speak:测试消息
    客户端断开连接
    成功生成(总时间:0 秒)
      

  6.   

    多线程测试结果
    服务端debug:
    服务端收到并回发消息:测试消息
    与客户端断开连接
    服务端收到并回发消息:第二个线程测试消息
    与客户端断开连接
    服务端收到并回发消息:第三个线程测试消息
    与客户端断开连接能给分不,要是不行明天把这改成图形界面,改成简单的聊天室