Socket socket = new Socket("192.168.137.1",9000);//tcp连接,这是客户端
OutputStream outputStream = socket.getOutputStream();先把服务器和客户端建立tcp连接,首先服务器端向客户端发送消息。客户端再把接收到的消息发送给服务器端。
程序要求的要求:刚开始的时候,客户端不向服务器发送数据,但是tcp连接已经建立,如何实现客户端接收到了服务器的数据,可以通过原有的socket再发送给tcp(之前该socket没有数据发送,此时接收到了数据)先谢谢了!

解决方案 »

  1.   

        因为socket的Stream是阻塞的,InputStream和OutputStream是不能同时一起工作的,所以从设计的角度不建议将输入和输出放在同一个Socket上实现(特别是长连接),而是用不同的Socket来分别实现。
        如果你一定要用同一个Socket来实现的话,方法是有,不过要付出代价。如服务端先是通过OutputStream输出数据,再通过InputStream获取数据,那么在输出数据后要调用socket.shutdownOutput()关闭输出流(同时客户端的InputStream也会关闭),才可以使用InputStream获取数据。但是关闭掉的流就不能再用了(这就是代价),所以它只支持你一个来回的操作。如果你是要一直交互的,那么用这种方式是行不通的。
      

  2.   

    将socket保存起来,最好使用这个filechannel
      

  3.   

    嗯,用两个socket来通信,一个发,一个收。我是先有发的socket的,在服务器端有连接,不过这个时候不发数据。再通过收的socket接收服务器端的数据,在客户端一旦接收到了数据,则通知发的socket来发送数据(注意,这个时候不重新new socket,而是调用原来发的socket发送数据)。
    请问该怎么实现呢?
      

  4.   


    public class Client {
    private final Socket receiver;
    private final Socket sender;

    public Client() {
    receiver = ...;
    sender = ...;
    }

    public void receive() {
    while (true) {
    接收...
    send(msg);
    }
    }

    public void send(String msg) {
    ...
    }
    }当然服务端也是一个发,一个收。
      

  5.   

    把OutputStream outputStream和InputStream inputStream变成全局变量就可以了,new socket()时给其赋值
      

  6.   

    private OutputStream outputStream;
    private InputStream inputStream;
    .
    .
    .
    Socket socket = new Socket("192.168.137.1",9000);
    outputStream = socket.getOutputStream();
    inputStream = socket.getInputStream();
    客户端的inputStream收到信息后,再用outputStream发出信息
      

  7.   

    再比如,我在分线程ReceiverThread()中接收数据,在分线程senderThread()中发送数据。当然是先在程ReceiverThread()中接收数据后,把数据发传给senderThread()发送!现在有问题呢,怎么样实现从分线程ReceiverThread()中接收数据后,把数据发传给分线程senderThread()发送呢?怎么让senderThread()等待ReceiverThread()中的数据到来,再发送呢?谢谢大家呢!!!
    哎呀,愁了几天,实在是搞不定了!
      

  8.   

    写了个简单的例子,你试看看能用不,
    只是简单的把客户端控制台输出发送在服务器,
    服务器把内容打印出来,返回一个字符串给客户端,
    并且每5秒钟向所有客户端广播一次系统时间
    "java"
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.ArrayList;
    import java.util.Calendar;
    import java.util.List;
    import java.util.Timer;
    import java.util.TimerTask;public class TServerSocket {
    public static void main(String[] args){
    final List<SocketProcessor> socketList = new ArrayList<SocketProcessor>();
    try {
    ServerSocket serverSocket = new ServerSocket(12345);
    Timer timer = new Timer();
    timer.schedule(new TimerTask() {
    @Override
    public void run() {
    System.out.println("broadcast");
    for(SocketProcessor processor : socketList)
    processor.writeToString(Calendar.getInstance().getTime().toGMTString());
    }
    }, 100, 5000);
    while(true){
    Socket socket = serverSocket.accept();
    SocketProcessor processor = new SocketProcessor(socket);
    new Thread(processor).start();
    socketList.add(processor);
    }
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }class SocketProcessor implements Runnable{
    private Socket socket;
    private InputStream in = null;
    private OutputStream out = null;

    public SocketProcessor(Socket socket){
    this.socket = socket;
    try {
    in = socket.getInputStream();
    out = socket.getOutputStream();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }

    public void writeToString(String info){
    try {
    out.write(info.getBytes());
    out.flush();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }

    @Override
    public void run() {
    byte[] data = new byte[1024];
    while(true){
    try {
    int length = in.read(data);
    System.out.println(new String(data, 0, length));
    out.write("recived".getBytes());
    out.flush();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }

    }
      

  9.   

    "java"
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.net.Socket;
    public class TClientSocket {
    public static void main(String[] args){
    try {
    Socket socket = new Socket("localhost", 12345);
    ClientSocketProcessor processor = new ClientSocketProcessor(socket);
    new Thread(processor).start();
    while(true){
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    processor.writeToString(reader.readLine());
    }
    } catch (Exception e) {
    e.printStackTrace();
    }
    }
    }class ClientSocketProcessor implements Runnable{
    private Socket socket;
    private InputStream in;
    private OutputStream out;

    public ClientSocketProcessor(Socket socket){
    this.socket = socket;
    try {
    this.in = socket.getInputStream();
    this.out = socket.getOutputStream();
    } catch (IOException e) {
    e.printStackTrace();
    }
    } public void writeToString(String info){
    try {
    out.write(info.getBytes());
    out.flush();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }

    @Override
    public void run() {
    byte[] data = new byte[1024];
    while(true){
    try {
    int length = in.read(data);
    System.out.println(new String(data, 0, length));
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }
    }